agents-city 0.5.2 → 0.5.4

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.
 
@@ -1205,10 +1255,16 @@ def arranque_escalonado():
 
     registro = os.path.join(casa, "tmux.log")
     falso = os.path.join(fbin, "tmux")
+    # A tmux that writes down what it is told. FAKE_SESSION/FAKE_WINDOWS let a
+    # test say "this city is already open, with these windows in it", which is
+    # the only way to exercise the reconcile path without a real tmux server.
     open(falso, "w").write(
         '#!/bin/bash\nprintf "%s\\n" "$*" >> '
         + registro
-        + '\n[ "$1" = "has-session" ] && exit 1\nexit 0\n'
+        + '\nif [ "$1" = "has-session" ]; then [ -n "${FAKE_SESSION:-}" ] || exit 1; exit 0; fi'
+        + '\nif [ "$1" = "list-windows" ]; then'
+        + ' for w in ${FAKE_WINDOWS:-}; do echo "$w"; done; exit 0; fi'
+        + '\nexit 0\n'
     )
     os.chmod(falso, 0o755)
     falso_node = os.path.join(fbin, "node")
@@ -1310,6 +1366,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
@@ -1446,6 +1504,101 @@ def arranque_escalonado():
         "city-runtime.sh gateway seat" in asiento, asiento[:200],
     )
     card.pon_campo(ficha, "ui.seat", "")
+
+    # ── a city that is already open ──────────────────────────────────────────
+    #
+    # Adding a house to a running city used to do nothing you could see. The
+    # launcher's first act was "session exists → attach", so the card had four
+    # agents and tmux had three windows, and closing the terminal did not help:
+    # detaching from a tmux session is not ending it. The only way to meet the
+    # new agent was to kill the city — every agent running in it — and start
+    # over.
+    #
+    # These read the RAW tmux log rather than the decoded launch commands,
+    # because what is being asserted is which windows were created and which
+    # were left alone.
+    def crudo(**extra):
+        corre(**extra)
+        return open(registro).read()
+
+    log = crudo(FAKE_SESSION="1", FAKE_WINDOWS="seat api", CITY_SETTLE="0", CITY_STAGGER="0")
+    afirma(
+        "· happy: an agent added to a running city gets its window",
+        "new-window" in log and " -n docs " in log,
+        log[:600],
+    )
+    afirma(
+        "· and the window that was already open is not created twice",
+        log.count(" -n api ") == 0,
+        log[:600],
+    )
+    afirma(
+        "· non-happy: nothing is killed, ever",
+        "kill-window" not in log and "kill-session" not in log,
+        log[:600],
+    )
+    afirma(
+        "· non-happy: and the running session is not re-created underneath it",
+        "new-session" not in log,
+        log[:600],
+    )
+    afirma(
+        "· the new house is what you are looking at when it opens",
+        "select-window" in log and ":docs" in log.split("select-window")[-1][:40],
+        log.split("select-window")[-1][:80],
+    )
+    lineas = corre(FAKE_SESSION="1", FAKE_WINDOWS="seat api", CITY_SETTLE="0", CITY_STAGGER="0")
+    afirma(
+        "· non-happy: no runtime is started in a chair that is already sitting",
+        not any("CITY_BUS_ACTOR=seat" in l for l in lineas)
+        and any("CITY_BUS_ACTOR=docs" in l for l in lineas),
+        str(lineas)[:400],
+    )
+
+    log = crudo(FAKE_SESSION="1", FAKE_WINDOWS="seat api docs", CITY_SETTLE="0", CITY_STAGGER="0")
+    afirma(
+        "· happy: a city already whole opens no windows at all",
+        " -n api " not in log and " -n docs " not in log and "new-session" not in log,
+        log[:600],
+    )
+    afirma("· and still attaches", "attach" in log, log[-200:])
+
+    # The seat is the one window whose absence is not somebody's work in
+    # progress: a city without its chair is not a city.
+    log = crudo(FAKE_SESSION="1", FAKE_WINDOWS="api docs", CITY_SETTLE="0", CITY_STAGGER="0")
+    afirma(
+        "· happy: a session that outlived its own chair gets the chair back",
+        " -n seat " in log,
+        log[:600],
+    )
+    lineas = corre(FAKE_SESSION="1", FAKE_WINDOWS="api docs", CITY_SETTLE="0", CITY_STAGGER="0")
+    afirma(
+        "· and only the chair — the houses are left running",
+        any("CITY_BUS_ACTOR=seat" in l for l in lineas)
+        and not any("CITY_BUS_ACTOR=api" in l for l in lineas),
+        str(lineas)[:400],
+    )
+
+    # A window whose agent left the card may be mid-task. Say so; do not close
+    # it. The owner decides what to do with somebody's unfinished work.
+    sobra = subprocess.run(
+        ["bash", guion, "ana", "--claude", "--no-sync"],
+        capture_output=True, text=True, cwd=casa,
+        env=dict(os.environ, HOME=casa, AGENTS_CITY_DATA=datos, CITY_CODE_DIR=codigo,
+                 PATH=fbin + os.pathsep + os.environ["PATH"],
+                 FAKE_SESSION="1", FAKE_WINDOWS="seat api docs viejo"),
+    )
+    afirma(
+        "· non-happy: a window no longer on the card is reported, not closed",
+        "viejo" in sobra.stderr and "kill-window" in sobra.stderr,
+        sobra.stderr[-400:],
+    )
+    afirma(
+        "· and the killing is left to the person whose work it is",
+        "kill-window" not in open(registro).read(),
+        open(registro).read()[:400],
+    )
+
     shutil.rmtree(casa)
 
 

package/bin/test-serve.py

@@ -937,7 +937,52 @@ 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",
+        )
+        # And the same thing through the real server, which is where it actually
+        # bit: the resolver did not create the folder, but it asked `cities.lista`
+        # — and listing HEALS, which does `makedirs` on every managed city before
+        # deciding there is nothing to write. So the journal recreated the city it
+        # was recording the removal of, and raced this very cleanup while doing it.
+        # A 404 is chosen deliberately: its handler touches no city at all, so the
+        # only thing that can bring the folder back is the log line.
+        pide(puerto, "/api/no-such-thing?city=" + otra, metodo="POST", cuerpo={})
+        afirma(
+            "· non-happy: and a request naming a city that is gone leaves it gone",
+            not os.path.exists(otra),
+            f"{otra} came back from a log line",
+        )
+        # The listing itself, which is the part that writes.
+        antes_lista = os.path.exists(otra)
+        cities_mod = serve.cities
+        cities_mod.lista("halltest", tocando=False)
+        afirma(
+            "· non-happy: and listing this user's cities does not raise the dead either",
+            not antes_lista and not os.path.exists(otra),
+        )
 
         # ── the demo's remote control ────────────────────────────────────────
         print("  the demo's remote control")
@@ -1242,6 +1287,44 @@ def main():
             and "role.urgencias-web: triage" in carta,
             carta,
         )
+        # The frontmatter is what the launcher and the cage read. The BODY is
+        # what the SEAT reads — and for a while only the first one moved, so a
+        # city could have three agents and tell its own chair, in prose, that it
+        # had one. This fixture's card is frontmatter only, which is a card a
+        # person may legitimately hand-write, so the check needs a card shaped
+        # the way the wizard writes them.
+        import seat as _seat
+        from testlib import roster as _roster
+
+        ficha_completa = os.path.join(hallDatos, "halltest.md")
+        antes_carta = open(ficha_completa, encoding="utf-8").read()
+        _seat.escribe_ficha(
+            ficha_completa, "halltest", "cpto", _roster(("notas", "knowledge", "apuntes"))
+        )
+        st, _ = pide(
+            puerto,
+            "/api/agentes",
+            metodo="POST",
+            cuerpo={"name": "guardia", "kind": "code", "role": "dev"},
+        )
+        entera = open(ficha_completa, encoding="utf-8").read()
+        cuerpo_carta = entera.split("## Agents", 1)[-1].split("## ", 1)[0]
+        afirma(
+            "· happy: and the seat is told about it in the half of the card it reads",
+            st == 200 and "`guardia`" in cuerpo_carta and "`notas`" in cuerpo_carta,
+            cuerpo_carta[:300],
+        )
+        afirma(
+            "· non-happy: adding a house never eats the goals or the round history",
+            "## Round history" in entera and "## Current goals" in entera,
+            entera[-400:],
+        )
+        with open(ficha_completa, "w", encoding="utf-8") as f:
+            f.write(antes_carta)
+        afirma(
+            "· non-happy: a hand-written card with no roster section is left alone",
+            "## Agents" not in open(ficha_completa, encoding="utf-8").read(),
+        )
         st, _ = pide(
             puerto, "/api/agentes", metodo="POST",
             cuerpo={"name": "urgencias web", "kind": "code", "role": "dev"},