agents-city 0.3.0-beta.21

package/plugin/scripts/seat.py

@@ -0,0 +1,1349 @@
+#!/usr/bin/env python3
+"""Sit down to work. One command, no account, no setup.
+
+    ./bin/seat                  open the selected city (creates `home` first time)
+    ./bin/seat --repos          choose your folders again
+    ./bin/seat --agent-roles    choose what role each repo agent adopts
+    ./bin/seat --goal           set your goal again
+    ./bin/seat --engines        what runs in each window: a model, or another CLI
+    ./bin/seat --domain software change the city's work domain
+    ./bin/seat --role dev       set your role without being asked
+    ./bin/seat --city home      open one specific city
+    ./bin/seat --no-yolo        repo windows with confirmations on
+    ./bin/seat --only a,b       just these folders this time
+
+Five questions the first time — the work domain, your chair role inside it, your
+folders and each repo agent's role, one goal, and what runs in each window. Enter
+keeps everything on your own Claude; a window can run a picked model, or another
+CLI entirely — Codex, OpenCode, Kimi, or an explicit terminal fallback.
+Then a tmux session: one window per folder you answer for, each with its assigned
+operating role and agent already running, and a `seat` window holding the chair
+role. Every repo runtime receives chaired assignments through one local bus and
+never addresses another repo runtime directly.
+
+It installs what it needs rather than telling you to: tmux, the city plugin, and
+the separate GitHub CLI `gh` **only if** you choose to read your folders from
+GitHub. `gh` is not bundled inside the npm package. That last one is a
+choice on purpose — reading your disk asks nobody for anything and needs no
+account, so it is the default, and installing a GitHub client and opening a login
+flow at everybody would take that away.
+
+None of this needs Cloudflare or an account. A user owns several autonomous
+cities under ``~/.agents-city/<user>/<city>``; each has one seat, one role and
+goal inside one work domain, its support repo agents and explicit roads to other
+cities. Skills remain
+installed in their repos and are discovered, never copied into the city.
+
+Requires tmux and bash, so on Windows run it inside WSL.
+"""
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+GUIONES = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, GUIONES)
+import card  # noqa: E402  a card: read, written
+import gh  # noqa: E402  who you are, and what GitHub knows
+import roles  # noqa: E402  the catalogue and the bus suffixes
+import domains  # noqa: E402  work domain -> relevant role and knowledge packs
+import ui  # noqa: E402  the terminal widgets
+import units  # noqa: E402  the districts file, one writer
+import cities  # noqa: E402  which cities exist, and what each is called
+import parcels  # noqa: E402  the houses file, one writer
+
+# Where the clone is, when there is one. The session script and the map live in it;
+# neither is needed to open a seat, and a seat opened from an installed plugin has no
+# clone at all.
+RAIZ = os.path.dirname(os.path.dirname(GUIONES))
+
+# Nothing about roles, identity or a card is decided in this file. It asks the
+# questions; roles.py, gh.py and card.py hold the answers, and the wizard reads the
+# same three. Every one of those started as a copy in here, and every copy drifted.
+
+
+# Running things and finding programs is gh.py's job; a private copy here is how
+# the two doors drift. The long timeout matters: find-repos.sh's first crawl of a
+# big home directory is slow, and killing it half-way looks like an empty disk.
+def sh(args, **kw):
+    return gh.sh(args, timeout=kw.pop("timeout", 300), **kw)
+
+
+hay = gh.hay
+
+# One progress contract for the whole first-run flow. Nested source/clone screens
+# remain inside the folders step rather than pretending they are extra decisions.
+PASOS = 6
+
+
+def instala(programa, formulas):
+    """Install one thing with whatever package manager is here. `formulas` maps a
+    manager to the package name, because they disagree (`gh` vs `github-cli`)."""
+    for gestor, plantilla in (
+        ("brew", ["brew", "install", "{}"]),
+        ("apt-get", ["sudo", "apt-get", "install", "-y", "{}"]),
+        ("dnf", ["sudo", "dnf", "install", "-y", "{}"]),
+        ("pacman", ["sudo", "pacman", "-S", "--noconfirm", "{}"]),
+    ):
+        if gestor in formulas and hay(gestor):
+            orden = [p.format(formulas[gestor]) for p in plantilla]
+            print(f"  Installing {programa}: {' '.join(orden)}\n")
+            subprocess.run(orden)
+            return hay(programa)
+    return False
+
+
+def asegura_tmux():
+    """tmux, installed if it is not there.
+
+    The whole promise is one command, and "first go and install tmux" is a second
+    one. So this installs it with whatever package manager the machine has, says so
+    out loud, and if there is none it prints the exact line to run rather than a
+    guess about what went wrong.
+    """
+    if hay("tmux"):
+        return True
+    print("  tmux is not here, and the session is made of tmux windows.")
+    if instala("tmux", {"brew": "tmux", "apt-get": "tmux", "dnf": "tmux", "pacman": "tmux"}):
+        print("\n  tmux installed.\n")
+        return True
+    print(
+        "\n  I could not install it. Install tmux and run this again:\n"
+        "    macOS:  brew install tmux\n"
+        "    Debian: sudo apt-get install tmux\n",
+        file=sys.stderr,
+    )
+    return False
+
+
+def gh_conectado():
+    """Whether `gh` is here AND logged in. Both, because an installed-but-anonymous
+    gh fails on the first list with a message about scopes that reads like a bug."""
+    return gh.conectado()
+
+
+def asegura_gh():
+    """The GitHub CLI, installed and logged in — only ever called because somebody
+    chose to read their repos from GitHub.
+
+    Deliberately not part of the default path. "No account needed" is the thing that
+    makes a seat work on its own, and installing a GitHub client and opening a login
+    flow at everybody is the opposite of that. Reading from your disk asks nobody
+    for anything, so it stays the default and this stays a choice.
+    """
+    if gh_conectado():
+        return True
+    if not hay("gh"):
+        print(
+            "\n  GitHub access uses the separate `gh` system CLI. It is not bundled "
+            "inside the npm package, and it is not installed unless you choose "
+            "GitHub here."
+        )
+        if not instala("gh", {"brew": "gh", "apt-get": "gh", "dnf": "gh", "pacman": "github-cli"}):
+            print(
+                "  I could not install it. Either install it —\n"
+                "    macOS:  brew install gh\n"
+                "    Debian: sudo apt-get install gh\n"
+                "  — or pick your repos from this disk instead.\n",
+                file=sys.stderr,
+            )
+            return False
+    if not gh_conectado():
+        print(
+            "\n  Opening GitHub OAuth in your browser. The terminal also shows a one-time\n"
+            "  device code, so the same flow works when the browser cannot open.\n"
+        )
+        # No capture: this one is a conversation, and swallowing its output would
+        # leave somebody staring at a frozen terminal waiting for a device code.
+        gh.autentica_web()
+        if not gh_conectado():
+            print("\n  Still not logged in. Falling back to this disk.\n", file=sys.stderr)
+            return False
+    print()
+    return True
+
+
+def asegura_plugin(usuario, agente, datos):
+    """The city plugin, installed and pointed at your card.
+
+    Without it the seat window is a plain Claude session: no `/city:goals`, no
+    `/city:round`, no skills. With it, and with no bus deployed anywhere, it is
+    your role with its commands — which is exactly what level 2 should be.
+
+    The two bus fields stay empty on purpose. They are what makes you reachable by
+    somebody else's agent, and that is a different level; the plugin used to mark
+    them required, which meant a person working alone was nagged for credentials to
+    a bus that did not exist.
+    """
+    if not hay("claude"):
+        print("  (claude is not on PATH, so I am skipping the plugin — the session still opens.)")
+        return
+    instalados = sh(["claude", "plugin", "list"])
+    if "city@agents-city" in instalados:
+        instalada = ""
+        m = re.search(r"city@agents-city.*?^\s*Version:\s*(\S+)", instalados, re.M | re.S)
+        if m:
+            instalada = m.group(1)
+        manifiestos = [
+            os.path.join(RAIZ, "plugin", ".claude-plugin", "plugin.json"),
+            os.path.join(os.path.dirname(GUIONES), ".claude-plugin", "plugin.json"),
+        ]
+        deseada = ""
+        for manifiesto in manifiestos:
+            try:
+                deseada = str(json.load(open(manifiesto, encoding="utf-8")).get("version") or "")
+            except (OSError, ValueError, TypeError):
+                continue
+            if deseada:
+                break
+        # Older Claude versions did not print plugin versions. Silence remains
+        # safer than reinstalling on every seat launch when comparison is
+        # impossible. Current Claude updates only on an observed mismatch.
+        if not instalada or not deseada or instalada == deseada:
+            return
+        print(f"  Updating the city plugin from {instalada} to {deseada}…")
+        actualiza = subprocess.run(
+            [
+                "claude",
+                "plugin",
+                "update",
+                "city@agents-city",
+                "--scope",
+                "user",
+                "--yes",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        if actualiza.returncode == 0:
+            print("    · updated; the new city windows will load this version")
+        else:
+            print("    · the existing plugin remains enabled; its update did not complete")
+        return
+    print("  Installing the city plugin, so your seat has its commands…")
+    if "agents-city" not in sh(["claude", "plugin", "marketplace", "list"]):
+        subprocess.run(
+            ["claude", "plugin", "marketplace", "add", RAIZ], capture_output=True, text=True
+        )
+    # No --config here on purpose. It writes into the user's global settings.json,
+    # and it only ever runs on a fresh install — so a plugin somebody installed by
+    # hand first would never get configured, which is how this was wrong a moment
+    # ago. The session passes AGENTS_CITY_DATA and CITY_BUS_AGENT in the
+    # environment instead, and city_env.py reads the environment before anything
+    # else. Same answer, nothing written to a file you did not ask us to touch.
+    r = subprocess.run(
+        ["claude", "plugin", "install", "city@agents-city", "-y"], capture_output=True, text=True
+    )
+    if "Successfully installed" in r.stdout or "already installed" in r.stdout:
+        print(
+            f"    · installed. Your seat is {agente}, reading "
+            f"{datos.replace(os.path.expanduser('~'), '~')}"
+        )
+        print("    · no bus token needed — local roads work without one")
+    else:
+        print("    · could not install it; the session still opens without it.")
+        if r.stderr.strip():
+            print(f"      {r.stderr.strip().splitlines()[0]}")
+
+
+def quien_soy():
+    """Your git email, minus the domain. Wrong for maybe one person in twenty, and
+    for them the argument exists — which beats asking twenty people a question
+    nineteen already answered by configuring git.
+
+    The email-to-username rule lives in gh.py and is imported, not repeated. It was
+    repeated once, and the two copies disagreed: this one turned
+    `12345678+alice@…` into `12345678alice` while the wizard turned it into `alice`,
+    so the same person got two different cards depending on the door.
+    """
+    if os.environ.get("AGENTS_CITY_USER"):
+        return gh.usuario_de_correo(os.environ["AGENTS_CITY_USER"])
+    correo = sh(["git", "config", "user.email"]).strip()
+    return gh.usuario_de_correo(correo) or os.environ.get("USER", "me")
+
+
+def donde_viven_las_fichas(usuario=""):
+    """The selected city, through the one resolver every door shares."""
+    return cities.actual(usuario or quien_soy())
+
+
+def repos_del_disco():
+    """Every repo cloned on this machine, by the name on its remote.
+
+    find-repos.sh already does this and caches it for a day, which matters: the
+    first crawl of a full home directory is not fast, and nobody wants to wait for
+    it twice.
+    """
+    salida = sh([os.path.join(GUIONES, "find-repos.sh")])
+    fuera = []
+    for linea in salida.splitlines():
+        if "\t" in linea:
+            nombre, ruta = linea.split("\t", 1)
+            fuera.append((nombre.strip(), ruta.strip()))
+    return fuera
+
+
+def ultimo_commit(ruta):
+    return sh(["git", "-C", ruta, "log", "-1", "--format=%ad", "--date=short"]).strip()
+
+
+def mios(usuario, correo, repos):
+    """Which of these you have actually committed to in the last year. The picker
+    starts with these ticked, so the common case is look-and-confirm rather than
+    hunting your own repos out of a list of two hundred."""
+    marcados = set()
+    for nombre, ruta in repos:
+        autores = sh(["git", "-C", ruta, "log", "--since=1.year", "--format=%ae"])
+        if any(
+            a.split("@")[0].strip().lower() in (usuario, correo.split("@")[0].lower())
+            for a in autores.splitlines()
+            if a.strip()
+        ):
+            marcados.add(nombre)
+    return marcados
+
+
+def escribe_ficha(ruta, usuario, rol, repos, objetivo=None, ciudad="", repo_roles=None):
+    """The card. Everything the seat, a round and the map read about a person.
+
+    The goal block comes from card.py, which the wizard also uses — a round reads
+    whichever door produced the card and must not be able to tell.
+    """
+    agente = roles.agente(usuario, rol, ciudad)
+    asignados = card.normaliza_roles_repos(repos, repo_roles)
+    fm = [
+        "---",
+        f"user: {usuario}",
+        f"name: {usuario}",
+        f"role: {rol}",
+        f"agent: {agente}",
+        "repos: [" + ", ".join(sorted(repos)) + "]",
+        *(f"role.{card.ventana(repo)}: {rol_repo}" for repo, rol_repo in asignados.items()),
+        f"goals_defined: {'true' if objetivo else 'false'}",
+        "---",
+    ]
+
+    oficio = roles.oficio(rol, os.path.dirname(ruta))
+    cuerpo = [
+        "",
+        f"# {usuario}",
+        "",
+        card.linea_rol(rol, oficio),
+        "",
+        "## Repos",
+        "",
+    ]
+    if repos:
+        cuerpo += [
+            "Answers for: " + ", ".join(f"`{r}`" for r in sorted(repos)) + ".",
+            "",
+            "Change them with `./bin/seat --repos`.",
+        ]
+    else:
+        cuerpo += [
+            "Owns no folders, on purpose. This role holds a property of "
+            "everybody else's — so it has no houses, and what it is for "
+            "begins where there is more than one city to reach.",
+            "",
+            "If that is wrong: `./bin/seat --repos`.",
+        ]
+    cuerpo += ["", "## Current goals", ""]
+
+    cuerpo += card.bloque_objetivo(objetivo)
+    if objetivo:
+        cuerpo += ["_Set when this seat was opened._", ""]
+
+    cuerpo += ["## Round history", "", "Rounds leave their summary here, most recent first.", ""]
+    open(ruta, "w", encoding="utf-8").write("\n".join(fm + cuerpo))
+
+
+def pregunta_dominio(actual=""):
+    """The city's work context, before asking which responsibility the seat has."""
+    packs = domains.catalogo()
+    elegido = ui.una(
+        "What domain does this city work in?",
+        [(p["id"], p["name"], p["summary"]) for p in packs],
+        1,
+        PASOS,
+        ayuda="The domain chooses the vocabulary, evidence standard and relevant "
+        "roles. Its knowledge pack is copied into the city as editable "
+        "Markdown. Repo skills remain in their repos.",
+    )
+    return domains.canonico(elegido) if elegido else None
+
+
+def pregunta_rol(dominio="software", actual=""):
+    """Which role inside the selected domain. Asked of everybody, always.
+
+    It used to be asked only of somebody who picked no repos, and defaulted to `dev`
+    otherwise — which put every architect, surveyor and designer on the bus as
+    `<user>/dev`. The role is what the seat window *is*: it decides what reaches you
+    and the name you answer to. It is not a thing to infer.
+    """
+    pack = domains.obtiene(dominio) or domains.obtiene("software")
+    catalogo = {r: (n, d, transversal) for r, n, d, transversal in roles.CATALOGO}
+    ops = []
+    for rol, _ in pack["roles"]:
+        nombre, descripcion, transversal = catalogo.get(
+            rol, (roles.nombre(rol), "", roles.transversal(rol))
+        )
+        if not transversal:
+            descripcion += "  ·  owns workspaces and answers for them"
+        ops.append((rol, nombre, descripcion))
+    return ui.una(
+        f"Which role is yours in {pack['name']}?",
+        ops,
+        2,
+        PASOS,
+        ayuda="The domain says what kind of work this is. Your role says what the "
+        "owner seat is accountable for: what it asks support agents and what "
+        "must reach it. The seat remains the chair even if you choose blank. "
+        "Owning no folders is valid for a cross-cutting role.",
+    )
+
+
+def _opciones_rol(roles_pack, actual="", dominio_extra=""):
+    """Picker rows for role ids, with the current choice first when present."""
+    catalogo = {r: (n, d) for r, n, d, _ in roles.CATALOGO}
+    ids = list(dict.fromkeys(r for r, _ in roles_pack))
+    if actual and actual not in ids:
+        ids.insert(0, actual)
+    elif actual in ids:
+        ids.remove(actual)
+        ids.insert(0, actual)
+    fuera = []
+    for rol in ids:
+        nombre, descripcion = catalogo.get(rol, (roles.nombre(rol), "custom role"))
+        sufijo = f" · {dominio_extra}" if dominio_extra else ""
+        if rol == actual:
+            sufijo += " · current"
+        fuera.append((rol, nombre, descripcion + sufijo))
+    return fuera
+
+
+def pregunta_rol_agente(repo, dominio, actual="blank"):
+    """Choose one repo agent's operating role without confusing it with authority.
+
+    Roles from the city domain are one short list. ``another-domain`` opens the
+    other built-in packs, so a software city can deliberately give a portfolio
+    repo an SEO role. The seat remains the only chair either way.
+    """
+    pack = domains.obtiene(dominio) or domains.obtiene("software")
+    actual = card.rol_seguro(actual)
+    ops = _opciones_rol(pack["roles"], actual)
+    ops.append(
+        (
+            "another-domain",
+            "Role from another domain…",
+            "marketing, finance, legal, medicine, research, sales or operations",
+        )
+    )
+    elegido = ui.una(
+        f"What role should the {repo} agent adopt?",
+        ops,
+        3,
+        PASOS,
+        ayuda="This is the repo agent's specialty, not authority. The city seat "
+        "remains its chair. Blank is an explicit role with no preset knowledge.",
+    )
+    if elegido is None:
+        return None
+    if elegido != "another-domain":
+        return elegido
+
+    packs = domains.catalogo()
+    otro = ui.una(
+        f"Which role family fits the {repo} agent?",
+        [(p["id"], p["name"], p["summary"]) for p in packs],
+        3,
+        PASOS,
+        ayuda="The repo stays in this city. This only chooses the specialist "
+        "vocabulary and role knowledge its agent adopts.",
+    )
+    if otro is None:
+        return None
+    elegido_pack = domains.obtiene(otro)
+    return ui.una(
+        f"What role should the {repo} agent adopt?",
+        _opciones_rol(elegido_pack["roles"], "", elegido_pack["name"]),
+        3,
+        PASOS,
+        ayuda="The seat remains the boss and the only router. This role controls "
+        "the perspective and evidence expected from this repo agent.",
+    )
+
+
+def pregunta_roles_repos(repos, dominio, actuales=None):
+    """One explicit operating role per concrete support agent."""
+    actuales = dict(actuales or {})
+    fuera = {}
+    for repo in sorted(repos):
+        elegido = pregunta_rol_agente(repo, dominio, actuales.get(repo, "blank"))
+        if elegido is None:
+            return None
+        fuera[repo] = elegido
+    return fuera
+
+
+def pregunta_objetivo(usuario):
+    """One goal, with the command that measures it. Skippable, and it says so.
+
+    Not optional decoration: a round with no goal degrades into a status report,
+    because there is nothing to contrast the work against. But refusing to open a
+    seat until somebody has invented a metric is worse, so an empty title skips it.
+    """
+    if not ui.pantalla(
+        "One goal, and the command that measures it",
+        "This is the part that does not change. Whatever your work is made of, "
+        "what holds it together is one goal, with the command that measures it.\n\n"
+        'A goal you cannot measure is not a goal here. "Improve performance" '
+        'cannot be accepted or refused with any judgement; "the p95 drops from '
+        '800 ms to 400 ms" can. And the measure is written, not described: if '
+        "the signal can be pulled with a command, that command is part of the "
+        "goal.\n\n"
+        "Skip it and your seat still opens. It just cannot tell you whether "
+        "anything is going well.",
+        4,
+        PASOS,
+        "enter to set one · q to skip",
+    ):
+        return None
+    titulo = ui.pide(
+        "The goal, in one line",
+        "",
+        ayuda="What has to be achieved. Concrete enough to argue with. "
+        "Empty skips the goal entirely — set it any time with "
+        "./bin/seat --goal.",
+    )
+    if not titulo:
+        return None
+    # A measure is a command that returns a number, or a person's judgement written
+    # down. The second is a first-class answer, not a fallback: "quality of the
+    # AGENTS.md files, read by the architect on Fridays" is a real goal with no
+    # number anywhere. Every question from here on takes empty as "to be defined".
+    signal = (
+        ui.pide(
+            "How is it measured",
+            "",
+            ayuda="The signal that says whether it is going well. It does "
+            "not have to be a number — prose is a real answer. "
+            "Empty = to be defined.",
+        )
+        or ""
+    )
+    comando = (
+        ui.pide(
+            "The command that returns it, if a command can",
+            "",
+            ayuda="Runnable as written. Leave it EMPTY for a qualitative "
+            "goal — the next question asks who judges it instead.",
+        )
+        or ""
+    )
+    manual = ""
+    if not comando:
+        manual = (
+            ui.pide(
+                "Who judges it, and how often",
+                "",
+                ayuda='In prose: "the architect reads the AGENTS.md files '
+                'on Fridays". Empty = to be decided.',
+            )
+            or ""
+        )
+    return {
+        "user": usuario,
+        "title": titulo,
+        "signal": signal,
+        "command": comando,
+        "manual": manual,
+        "baseline": ui.pide(
+            "Where it stands today",
+            "",
+            ayuda="Run the command, or say it in words. Empty = not measured yet.",
+        )
+        or "",
+        "target": ui.pide("Where it has to get to", "", ayuda="Empty = to be defined.") or "",
+        "by": ui.pide("By when", "this quarter") or "this quarter",
+    }
+
+
+# The agent CLIs a window can run instead of Claude, offered when they are on the
+# PATH. Unknown CLIs use the visibly labelled terminal compatibility fallback;
+# a local model can still arrive through a native OpenCode command pointed at an
+# OpenAI-compatible endpoint such as LM Studio or Ollama.
+OTROS_MOTORES = ("codex", "opencode", "kimi")
+
+
+def motor_de_ventana(win):
+    """One window's engine. Returns the card keys to write for it — empty values
+    clear a key back to the default — or None when the question was quit."""
+    ops = [
+        (
+            "claude",
+            "Claude",
+            "the /city: commands live here"
+            if win == "seat"
+            else "your default, or pick a model next",
+        )
+    ]
+    ops += [(m, m, "on this machine") for m in OTROS_MOTORES if shutil.which(m)]
+    ops.append(
+        (
+            "otro",
+            "another command (terminal fallback)",
+            "verbatim, flags included — explicit compatibility mode; "
+            "known runtimes never use terminal injection",
+        )
+    )
+    ayuda = (
+        "Claude reads the model from the card; any other CLI is launched "
+        "exactly as written, so its model goes in its own flags. Change it "
+        "any time: ./bin/seat --engines"
+    )
+    if win == "seat":
+        ayuda = (
+            "This is your own window, the one that holds your role. On Claude "
+            "it also carries the `/city:` commands and the plugin; on anything "
+            "else you keep your folder and your identity, and the same jobs "
+            "are done from the terminal (`agents-city seat --goal`, `--engines`, "
+            "`exit`). Pick another CLI here and the city has no Claude in it "
+            "at all — which is a real answer."
+        )
+    motor = ui.una(f"The `{win}` window runs…", ops, ayuda=ayuda)
+    if motor is None:
+        return None
+    if motor == "claude":
+        modelo = ui.pide("Model for this window (empty = your default)", "") or ""
+        esfuerzo = ""
+        if modelo:
+            esfuerzo = ui.pide("Effort (low…max, empty = default)", "") or ""
+        return {f"runs.{win}": "", f"model.{win}": modelo, f"effort.{win}": esfuerzo}
+    orden = (
+        ui.pide(
+            "The exact command",
+            "" if motor == "otro" else str(motor),
+            ayuda="Launched verbatim in the window, flags included.",
+        )
+        or ""
+    )
+    if not orden:
+        return {}
+    if motor == "otro" and not orden.startswith("terminal:"):
+        orden = "terminal:" + orden
+    return {f"runs.{win}": orden, f"model.{win}": "", f"effort.{win}": ""}
+
+
+def pregunta_motores(elegidos):
+    """What starts in each window. Enter keeps every window on the person's own
+    Claude default, which is the right silence — no keys land on the card.
+
+    Returns None on a quit, {} for "leave everything as it is", or card keys to
+    write. Choosing Claude for a window CLEARS its `runs.`/`model.`/`effort.`
+    keys, so coming back from codex to plain Claude is the same gesture as
+    leaving; quitting one window's question skips that window untouched.
+
+    The seat's own window is asked about first, and it is asked even when you own
+    no folders: there is always a seat, and a person who wants no Claude anywhere
+    has to be able to say so.
+    """
+    eleccion = ui.una(
+        "What runs in each window?",
+        [
+            (
+                "claude",
+                "Claude, as it is now",
+                "every window starts your own Claude — nothing written",
+            ),
+            (
+                "elegir",
+                "Pick per window",
+                "a model per window, or another CLI: Codex, OpenCode, Kimi, terminal fallback",
+            ),
+        ],
+        5,
+        PASOS,
+        ayuda="Each folder gets a window with an agent in it. This decides which "
+        "agent — and it is the skippable question: enter, and everything "
+        "runs your Claude.",
+    )
+    if eleccion is None:
+        return None
+    if eleccion != "elegir":
+        # 'claude' — and anything a script answers that is not a real choice.
+        return {}
+    cambios = {}
+    for win in ["seat"] + [card.ventana(r) for r in sorted(elegidos)]:
+        cambios.update(motor_de_ventana(win) or {})
+    return cambios
+
+
+def escribe_suelo(datos, repos, dominio="software"):
+    """The least a map needs to draw: districts, and a house per repo.
+
+    Written only into our own folder and only when it is not there — a real data
+    repo's units.yml is somebody's modelling and this must never sit on top of it.
+
+    Why bother at all: "my city is my folders" should be true straight after
+    `./bin/seat`, with no wizard. The seeder degrades to an empty list when these
+    files are missing, and an empty list of districts is a map with no ground, so
+    the honest minimum is one district holding everything. Splitting repos into
+    parcels across real business units is the modelling nothing can do for you —
+    but it is an improvement on this, not a prerequisite for it.
+    """
+    # No folders, no ground. Writing a district called "Mine" holding nothing is a
+    # lie about the shape of somebody's work, and under this model an empty city is
+    # a real answer rather than a half-finished one: a cross-cutting role lives on
+    # the roads between cities, and the roads are the bus.
+    # Domain belongs to the city even when it deliberately has no support repos.
+    # ``selecciona`` validates and writes only that scalar.
+    domains.selecciona(datos, dominio)
+    if not repos:
+        return []
+
+    hechos = []
+    u = os.path.join(datos, "units.yml")
+    if not os.path.exists(u):
+        # Written by the module that owns the format — the same one the hall's
+        # editor and the seeder read. This used to be a third inline copy.
+        units.escribe(u, [{"id": "mine", "name": "Mine", "color": "3fb8a0"}])
+        hechos.append('units.yml — one district, "Mine"')
+
+    p = os.path.join(datos, "parcels.yml")
+    if not os.path.exists(p):
+        parcels.escribe(p, {r: [{"ruta": "", "unidad": "mine", "nombre": r}] for r in repos})
+        hechos.append(
+            f"parcels.yml — {len(repos)} {'house' if len(repos) == 1 else 'houses'}, one per repo"
+        )
+
+    c = os.path.join(datos, "city.yml")
+    try:
+        texto = open(c, encoding="utf-8").read()
+    except OSError:
+        texto = ""
+    faltan = []
+    pack = domains.obtiene(dominio) or domains.obtiene("software")
+    if not card.campo("---\n" + texto + "---\n", "grow_command") and pack.get("grow_cmd"):
+        faltan.append(f"grow_command: {pack['grow_cmd']}")
+    if faltan:
+        if texto and not texto.endswith("\n"):
+            texto += "\n"
+        cities._atomico(c, texto + "\n".join(faltan) + "\n")
+        hechos.append("city.yml — domain-specific growth command")
+    return hechos
+
+
+def repos_de_ficha(ruta):
+    """The folders on a card. Was a subprocess to read-card.py, which is the same
+    parser this now imports — one process instead of two, and one parser."""
+    return card.lee(ruta).get("repos", [])
+
+
+def elige_fuente():
+    """Where the list of folders comes from. Disk first, and GitHub as a choice.
+
+    Order is the argument: reading your disk asks nobody for anything and works with
+    no account, so it is the default. GitHub is offered second because it is better
+    when your work is not all cloned yet — and picking it is what triggers installing
+    and logging in `gh`, rather than doing that to everybody up front.
+    """
+    if gh_conectado():
+        github_estado = "GitHub CLI ready and authenticated"
+    elif hay("gh"):
+        github_estado = "GitHub CLI installed · opens browser OAuth"
+    else:
+        github_estado = "installs the separate GitHub CLI · opens browser OAuth"
+    return ui.una(
+        "Where should I look for your folders?",
+        [
+            (
+                "disco",
+                "On this machine",
+                "every repo already cloned · no account, nothing installed",
+            ),
+            ("mia", "My GitHub account", f"your own repos, cloned or not · {github_estado}"),
+            ("org", "A GitHub organisation", f"work you share with other people · {github_estado}"),
+        ],
+        3,
+        PASOS,
+        ayuda="You can come back and change this with ./bin/seat --repos. "
+        "Anything you pick that is not cloned here, I offer to clone.",
+    )
+
+
+def repos_de_github(dueno, locales):
+    """A GitHub owner's repos, each marked with where it is on this disk or that it
+    is not here at all. A repo that is not cloned can still go on your card — it
+    just gets no window until it is, and the session says which ones it could not
+    find rather than quietly opening fewer windows."""
+    fuera = []
+    for nombre, descripcion, empujado in gh.repos(dueno):
+        ruta = locales.get(nombre, "")
+        fuera.append((nombre, ruta, empujado, descripcion or ("" if ruta else "not cloned here")))
+    return fuera
+
+
+def clona(dueno, faltan, destino):
+    """Clone what somebody picked and does not have. Asked, never assumed: it is
+    network and disk in somebody else's home directory."""
+    if not faltan:
+        return {}
+    corto = destino.replace(os.path.expanduser("~"), "~")
+    if not ui.pantalla(
+        f"{len(faltan)} of those are not on this machine",
+        f"{', '.join(faltan[:8])}{' …' if len(faltan) > 8 else ''}\n\n"
+        f"They can stay on your card either way — a folder you do not have just "
+        f"gets no window, and the session tells you which ones it could not "
+        f"find.\n\n"
+        f"Or I clone them into {corto} now, and they all get one.",
+        3,
+        PASOS,
+        "enter to clone them · q to leave them on the card",
+    ):
+        return {}
+    os.makedirs(destino, exist_ok=True)
+    puestas = {}
+    for nombre in faltan:
+        ruta = os.path.join(destino, nombre)
+        if os.path.isdir(ruta):
+            puestas[nombre] = ruta
+            continue
+        print(f"  cloning {dueno}/{nombre}…")
+        r = subprocess.run(
+            ["gh", "repo", "clone", f"{dueno}/{nombre}", ruta], capture_output=True, text=True
+        )
+        if os.path.isdir(ruta):
+            puestas[nombre] = ruta
+        else:
+            ultima = (r.stderr or "").strip().splitlines()
+            print(f"    could not: {ultima[-1] if ultima else 'unknown reason'}")
+    # The index is cached for a day and has just gone stale by definition.
+    subprocess.run([os.path.join(GUIONES, "find-repos.sh"), "--refresh"], capture_output=True)
+    return puestas
+
+
+def resuelve_fuente():
+    """Where the folder list comes from, GitHub resolved or fallen back from.
+
+    GitHub is a choice, and choosing it is what installs and logs in gh. If any of
+    that does not work out, fall back to the disk rather than dead-ending: the disk
+    always has an answer. Returns (fuente, dueno) or None on a quit."""
+    fuente = elige_fuente()
+    if fuente is None:
+        return None
+    dueno = ""
+    if fuente in ("mia", "org"):
+        if not asegura_gh():
+            fuente = "disco"
+        elif fuente == "mia":
+            dueno = sh(["gh", "api", "user", "--jq", ".login"]).strip()
+            if not dueno:
+                fuente = "disco"
+        else:
+            orgs = gh.orgs()
+            if not orgs:
+                ui.pantalla(
+                    "No organisations",
+                    "Your account does not belong to any organisation gh can "
+                    "see, or the token is missing the read:org scope.\n\n"
+                    "Reading from this disk instead.",
+                    3,
+                    PASOS,
+                )
+                fuente = "disco"
+            else:
+                dueno = ui.una("Which organisation?", [(o, o, "") for o in orgs], 3, PASOS)
+                if dueno is None:
+                    return None
+    return fuente, dueno
+
+
+def elige_repos(usuario, ya_marcados):
+    """Which folders are yours: where to read the list from, then which ones."""
+    locales = dict(repos_del_disco())
+    correo = sh(["git", "config", "user.email"]).strip()
+
+    r = resuelve_fuente()
+    if r is None:
+        return None
+    fuente, dueno = r
+
+    if fuente == "disco":
+        if not locales:
+            print(
+                "\n  I found no git repos on this machine.\n"
+                "  Clone something first, point the search somewhere else —\n"
+                "    CITY_SEARCH_IN=/where/they/are ./bin/seat\n"
+                "  — or run ./bin/seat --repos and read them from GitHub.\n",
+                file=sys.stderr,
+            )
+            return None
+        filas = [(n, r, ultimo_commit(r), "") for n, r in locales.items()]
+    else:
+        print(f"  Asking GitHub for the repos of {dueno}…")
+        filas = repos_de_github(dueno, locales)
+        if not filas:
+            print(f"\n  gh returned nothing for {dueno}.\n", file=sys.stderr)
+            return None
+
+    # Most recently touched first: the ones you are working in are the ones you are
+    # deciding about, and they should not be forty rows down.
+    filas.sort(key=lambda f: f[2] or "", reverse=True)
+    marcados = set(ya_marcados) or mios(usuario, correo, [(n, r) for n, r, _, _ in filas if r])
+
+    ops = []
+    for nombre, ruta, cuando, _ in filas:
+        donde = ruta.replace(os.path.expanduser("~"), "~") if ruta else "· not cloned here"
+        ops.append((nombre, nombre, f"{cuando or '—'}  {donde}"))
+
+    elegidos = ui.elige(
+        f"Which folders do you answer for, {usuario}?",
+        ops,
+        marcadas=marcados,
+        minimo=0,
+        step=3,
+        of=PASOS,
+        ayuda="One window each, with an agent in it. Ticked are the ones you have "
+        "commits in this year. Pick what you would answer a question about — "
+        "nothing is a valid answer for a role that owns no folders.",
+    )
+    if elegidos is None:
+        return None
+
+    rutas = {n: r for n, r, _, _ in filas if r}
+    if dueno:
+        faltan = [n for n in elegidos if n not in rutas]
+        rutas.update(
+            clona(dueno, faltan, os.environ.get("CITY_CODE_DIR", os.path.expanduser("~/codigo")))
+        )
+    return elegidos, rutas
+
+
+def dominio_configurado(a, nueva, datos):
+    """Resolve question one, including the explicit CLI non-interactive path."""
+    dominio_actual = domains.de_ciudad(datos)
+    if a.domain:
+        dominio = domains.canonico(a.domain)
+        if not domains.obtiene(dominio):
+            conocidos = ", ".join(p["id"] for p in domains.catalogo())
+            print(f"  Unknown domain {a.domain!r}. Available: {conocidos}.", file=sys.stderr)
+            return None
+        return dominio
+    return pregunta_dominio(dominio_actual) if nueva else dominio_actual
+
+
+def rol_configurado(a, nueva, dominio, actual=""):
+    """Resolve question two; a domain switch always asks for a matching role."""
+    if a.role:
+        return a.role
+    solo_otro_ajuste = a.goal or a.repos or a.agent_roles or a.engines
+    if nueva or a.domain or not solo_otro_ajuste:
+        return pregunta_rol(dominio, actual)
+    return actual or domains.roles_de(dominio)[0][0]
+
+
+def pregunta_seat_yolo(datos):
+    """Question six: whether the chair itself asks permission. Per city, in
+    city.yml — locally the seat is the owner's own hands on the owner's own
+    machine, and asking the owner for permission in their own chair is a
+    choice, not a law. Repo windows keep their own yolo/cage story either way.
+    False means the person quit the wizard."""
+    yolo_actual = cities.lee_clave(datos, "seat_yolo") == "1"
+    eleccion = ui.una(
+        "Does your own chair ask permission?",
+        [
+            (
+                "ask",
+                "Ask first" + ("" if yolo_actual else " (current)"),
+                "the seat confirms actions with you — the cautious default",
+            ),
+            (
+                "yolo",
+                "No prompts (yolo)" + (" (current)" if yolo_actual else ""),
+                "your chair acts without asking; repo windows keep their own cage",
+            ),
+        ],
+        6,
+        PASOS,
+        ayuda="Changeable any time: ./bin/seat --seat-yolo on|off. "
+        "Launching with --no-yolo still brakes the whole session, seat included.",
+    )
+    if eleccion is None:
+        return False
+    cities.pon_clave(datos, "seat_yolo", "1" if eleccion == "yolo" else "0")
+    return True
+
+
+def hay_ajustes(a, nueva):
+    """Whether this invocation re-asks any of the six questions."""
+    return bool(nueva or a.repos or a.agent_roles or a.goal or a.domain or a.role or a.engines)
+
+
+def pregunta_runtime(a, nueva, elegidos, datos):
+    """Questions five and six together: what runs in each window, and whether
+    the chair itself asks permission. None means the person quit; {} means
+    neither question was due this invocation."""
+    if not (nueva or a.engines):
+        return {}
+    motores = pregunta_motores(elegidos)
+    if motores is None or not pregunta_seat_yolo(datos):
+        return None
+    return motores
+
+
+def ajusta_seat_yolo(a, datos, nueva):
+    """The --seat-yolo flag: write the per-city choice. Returns True when the
+    invocation was ONLY this adjustment, so the caller can stop there."""
+    if not a.seat_yolo:
+        return False
+    cities.pon_clave(datos, "seat_yolo", "1" if a.seat_yolo == "on" else "0")
+    estado_seat = "yolo" if a.seat_yolo == "on" else "asks permission"
+    print(f"  Seat runtime for this city: {estado_seat} (city.yml seat_yolo).")
+    solo = not hay_ajustes(a, nueva)
+    if solo:
+        print("  It applies the next time the session opens.\n")
+    return solo
+
+
+def configura(a, ficha, nueva, datos, usuario):
+    """The six questions, or the setting being re-asked. False means quit."""
+    previo = open(ficha).read() if not nueva else ""
+
+    def campo(k, defecto=""):
+        return card.campo(previo, k, defecto)
+
+    # Domain owns the vocabulary and relevant roles; it is never inferred from
+    # repo names. Old `kind: product` cities resolve to software.
+    dominio = dominio_configurado(a, nueva, datos)
+    if not dominio:
+        return False
+    rol = rol_configurado(a, nueva, dominio, campo("role"))
+    if not rol:
+        return False
+
+    # 3. The folders.
+    if nueva or a.repos:
+        resultado = elige_repos(usuario, [] if nueva else repos_de_ficha(ficha))
+        if resultado is None:
+            return False
+        elegidos, _ = resultado
+    else:
+        elegidos = repos_de_ficha(ficha)
+
+    # Every concrete repo agent has a specialty distinct from the seat's chair
+    # role. Legacy cards resolve missing assignments to the honest blank role.
+    actuales_roles = card.lee(ficha).get("repo_roles", {}) if not nueva else {}
+    cambia_roles_repos = nueva or a.repos or a.agent_roles
+    if cambia_roles_repos:
+        roles_repos = pregunta_roles_repos(elegidos, dominio, actuales_roles)
+        if roles_repos is None:
+            return False
+    else:
+        roles_repos = card.normaliza_roles_repos(elegidos, actuales_roles)
+
+    # 4. The goal, which is the one thing a round cannot work without.
+    objetivo = None
+    if nueva or a.goal:
+        objetivo = pregunta_objetivo(usuario)
+    elif campo("goals_defined") == "true":
+        objetivo = card.objetivo(previo, usuario)
+
+    # 5 and 6. The engines, and whether the chair itself asks permission.
+    motores = pregunta_runtime(a, nueva, elegidos, datos)
+    if motores is None:
+        return False
+
+    escribe_cambios(
+        ficha,
+        nueva,
+        datos,
+        usuario,
+        dominio,
+        rol,
+        elegidos,
+        roles_repos,
+        objetivo,
+        a.goal,
+        motores,
+        cambia_roles_repos,
+    )
+    resume(datos, usuario, dominio, rol, elegidos, roles_repos, objetivo)
+    return True
+
+
+def escribe_cambios(
+    ficha,
+    nueva,
+    datos,
+    usuario,
+    dominio,
+    rol,
+    elegidos,
+    roles_repos,
+    objetivo,
+    con_goal,
+    motores,
+    actualiza_roles_repos,
+):
+    """Land the answers on the card — the whole template for a new one, surgery
+    for one that exists, because an existing card may carry round history and
+    changing your role must not erase what happened."""
+    if nueva:
+        escribe_ficha(
+            ficha,
+            usuario,
+            rol,
+            elegidos,
+            objetivo,
+            cities.slug_ciudad(datos),
+            roles_repos,
+        )
+    else:
+        card.cambia_rol(
+            ficha,
+            rol,
+            roles.agente(usuario, rol, cities.slug_ciudad(datos)),
+            roles.oficio(rol, datos),
+        )
+        card.cambia_repos(ficha, elegidos)
+        if actualiza_roles_repos:
+            card.cambia_roles_repos(ficha, elegidos, roles_repos)
+        if con_goal or objetivo is not None:
+            card.cambia_objetivo(ficha, objetivo)
+    # After the template or the surgery, either way: pon_campo is itself surgical.
+    for clave, valor in motores.items():
+        card.pon_campo(ficha, clave, valor)
+    domains.selecciona(datos, dominio)
+    conocimiento = domains.materializa(datos, dominio, rol)
+    for rol_repo in sorted(set(roles_repos.values()) - {"blank", rol}):
+        conocimiento += domains.materializa(datos, dominio, rol_repo)
+    if conocimiento:
+        print("  Domain knowledge installed as editable files: " + ", ".join(conocimiento) + ".")
+    otros = sorted(k.split(".", 1)[1] for k, v in motores.items() if v and k.startswith("runs."))
+    if otros:
+        print(f"  Windows on another engine: {', '.join(otros)} — the rest run Claude.")
+
+
+def resume(datos, usuario, dominio, rol, elegidos, roles_repos, objetivo):
+    """Say what was written, and what to do with it."""
+    print(f"  City address: {cities.direccion(usuario, datos)}.")
+    pack = domains.obtiene(dominio)
+    print(f"  Domain: {pack['name'] if pack else dominio}.")
+    print(f"  Your role there: {roles.nombre(rol)}.")
+    if elegidos:
+        print(
+            f"  {len(elegidos)} folders on your card — one window each. "
+            f"Change them with ./bin/seat --repos"
+        )
+        resumen_roles = ", ".join(
+            f"{repo}: {roles.nombre(roles_repos.get(repo, 'blank'))}" for repo in sorted(elegidos)
+        )
+        print(f"  Support-agent roles: {resumen_roles}.")
+    else:
+        print(
+            "  No support repos in this city. Its seat still opens on its own;\n"
+            "  roads can connect it to other local or remote cities."
+        )
+    print(f"  Goal: {objetivo['title'] if objetivo else 'none yet — ./bin/seat --goal'}")
+    # Only in our own folder: a real data repo's modelling is not ours to touch.
+    if cities.gestionada(datos, usuario):
+        for h in escribe_suelo(datos, elegidos, dominio):
+            print(f"    · {h}")
+        if elegidos:
+            print(
+                f"\n  Your city is drawable now — no wizard, no account:\n"
+                f"    ./bin/city {datos.replace(os.path.expanduser('~'), '~')}"
+            )
+    print()
+
+
+def ciudad_elegida(cual, usuario):
+    """--city resolved to a folder, the usual resolution otherwise, '' plus the
+    list of known cities on a miss — a wrong name should teach, not strand."""
+    if not cual:
+        return donde_viven_las_fichas(usuario)
+    datos = cities.resuelve(cual, usuario)
+    if not datos:
+        conocidas = ", ".join(c["slug"] for c in cities.lista(usuario)) or "none yet"
+        print(
+            f"  No city called {cual!r}. Known here: {conocidas}.\n"
+            f"  A path works too: ./bin/seat --city ~/clientes/acme\n",
+            file=sys.stderr,
+        )
+    return datos
+
+
+def entrega_a_la_sesion(a, datos, usuario):
+    """Hand over to the session builder, which is the part that already worked.
+
+    This replaces the process rather than waiting on it: from here on the session
+    script owns the terminal, and `seat` has no more decisions to take. The two
+    engine flags travel as environment because they belong to THIS launch and must
+    not be written to anybody's card.
+    """
+    orden = [os.path.join(GUIONES, "city-session.sh"), usuario, "--claude"]
+    if a.no_yolo:
+        orden.append("--no-yolo")
+    if a.no_sync:
+        orden.append("--no-sync")
+    if a.only:
+        orden += ["--only", a.only]
+    entorno = dict(
+        os.environ,
+        AGENTS_CITY_DATA=datos,
+        AGENTS_CITY_HOME=cities.raiz(),
+        AGENTS_CITY_USER=usuario,
+        CITY_ADDRESS=cities.direccion(usuario, datos),
+    )
+    if a.model:
+        entorno["CITY_MODEL"] = a.model
+    if a.effort:
+        entorno["CITY_EFFORT"] = a.effort
+    os.execve(orden[0], orden, entorno)
+
+
+def argumentos():
+    """Every flag the seat takes. Its own function so `main` stays readable: the
+    door's job is the order of the steps, not the shape of the arguments."""
+    ap = argparse.ArgumentParser(add_help=False)
+    ap.add_argument("usuario", nargs="?", default="")
+    ap.add_argument("--repos", action="store_true", help="pick your repos again")
+    ap.add_argument(
+        "--agent-roles",
+        "--agents",
+        action="store_true",
+        dest="agent_roles",
+        help="choose the operating role each repo agent adopts",
+    )
+    ap.add_argument("--goal", action="store_true", help="set your goal again")
+    ap.add_argument(
+        "--engines", action="store_true", help="what runs in each window: a model, or another CLI"
+    )
+    ap.add_argument(
+        "--city",
+        default="",
+        metavar="NAME|PATH",
+        help="which city to sit in (default: the usual resolution)",
+    )
+    ap.add_argument(
+        "--domain",
+        default="",
+        metavar="DOMAIN",
+        help="set the work domain (software, healthcare, legal...)",
+    )
+    ap.add_argument("--role", default="", help="set your role without being asked")
+    ap.add_argument("--no-yolo", action="store_true")
+    ap.add_argument(
+        "--seat-yolo",
+        default="",
+        choices=["on", "off"],
+        metavar="on|off",
+        help="whether the chair itself runs without permission prompts (stored per city)",
+    )
+    ap.add_argument("--no-sync", action="store_true")
+    ap.add_argument("--only", default="")
+    ap.add_argument(
+        "--model",
+        default="",
+        metavar="ALIAS",
+        help="this launch's model for every window (opus, sonnet, haiku…)",
+    )
+    ap.add_argument(
+        "--effort",
+        default="",
+        metavar="LEVEL",
+        help="this launch's effort (low, medium, high, xhigh, max)",
+    )
+    ap.add_argument("-h", "--help", action="store_true")
+    return ap.parse_args()
+
+
+def puerta_del_dueno(a, usuario):
+    """The two ownership refusals at the door: a second person cannot take this
+    seat, and another owner's city cannot be sat in. Returns the city folder,
+    or None with the reason already printed."""
+    if a.usuario and gh.usuario_de_correo(a.usuario) != usuario:
+        print(
+            "  A personal city has exactly one owner seat. To open another of "
+            "your cities, use `--city <name>`.",
+            file=sys.stderr,
+        )
+        return None
+    # v1 put the whole first city directly in ~/.agents-city. Move it once, with
+    # a recovery copy, before resolving the selected v2 city.
+    if not os.environ.get("AGENTS_CITY_DATA"):
+        cities.migra_legacy(usuario, anunciar=True)
+    datos = ciudad_elegida(a.city, usuario)
+    if not datos:
+        return None
+    owner = cities.lee_clave(datos, "owner")
+    if owner and owner != usuario:
+        print(
+            f"  This city belongs to {owner!r}, not {usuario!r}. Import one of "
+            "your own cities or connect it by road instead.",
+            file=sys.stderr,
+        )
+        return None
+    return datos
+
+
+def main():
+    a = argumentos()
+    if a.help:
+        print(__doc__)
+        return 0
+
+    usuario = quien_soy()
+    datos = puerta_del_dueno(a, usuario)
+    if not datos:
+        return 1
+    # Remember it, so every door — the hall's switcher included — can offer it.
+    cities.asegura_metadata(datos, usuario)
+    cities.registra(datos, usuario)
+    cities.selecciona(usuario, datos)
+    ficha = os.path.join(datos, f"{usuario}.md")
+    nueva = not os.path.exists(ficha)
+
+    if ajusta_seat_yolo(a, datos, nueva):
+        return 0
+
+    if hay_ajustes(a, nueva):
+        if nueva:
+            print(
+                f"\n  First time here. Six questions and you are in — the work "
+                f"domain, your chair role,\n  your folders and their agent roles, "
+                f"one goal, what runs in each window, "
+                f"and whether\n  your own chair asks permission. "
+                f"Your card lands at\n  "
+                f"{ficha.replace(os.path.expanduser('~'), '~')}\n"
+            )
+        if not configura(a, ficha, nueva, datos, usuario):
+            print("  Nothing changed.\n")
+            return 1
+
+    # Cards written before personal cities addressed the role (`user/lead`). A
+    # city address is stable when the role changes, and two cities never collide.
+    esperado = cities.direccion(usuario, datos)
+    leida = card.lee(ficha)
+    if leida.get("agent") != esperado:
+        card.pon_campo(ficha, "agent", esperado)
+
+    # Everything the session needs, installed rather than asked for. One command
+    # means one command: "now go and install tmux" is a second one.
+    if not asegura_tmux():
+        return 1
+    agente = card.lee(ficha).get("agent") or cities.direccion(usuario, datos)
+    # No Claude in the seat window, no reason to install a Claude plugin — and no
+    # reason to make somebody restart Claude Code for something they will not use.
+    if not card.campo(open(ficha, encoding="utf-8").read(), "runs.seat"):
+        asegura_plugin(usuario, agente, datos)
+
+    entrega_a_la_sesion(a, datos, usuario)
+
+
+if __name__ == "__main__":
+    sys.exit(main())