agents-city 0.3.0-beta.21 → 0.3.0

package/plugin/scripts/seat.py

@@ -2,24 +2,30 @@
 """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 --agents         build the roster again, agent by agent (--repos too)
     ./bin/seat --goal           set your goal again
-    ./bin/seat --engines        what runs in each window: a model, or another CLI
+    ./bin/seat --engines        what runs in your own chair: 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
+    ./bin/seat --only a,b       just these agents 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.
+Seven questions the first time — the work domain, your chair role inside it, the
+city's agents, one goal, what runs in your own chair, whether it asks permission,
+and whether the city goes on your desktop.
+
+The third question is the city itself, and it is a loop rather than a list: an
+agent is asked for in full — its name, the kind of work it does, its role,
+everything it works on, the engine and effort that run it, and the skills it
+starts with — and then you are asked for another, until you say the city is
+complete. An agent is not a repository: it may answer for three services and a
+folder of documents at once, or for documents alone with no git anywhere.
+
+Then a tmux session: one window per agent, each with its assigned operating role
+and engine already running, and a `seat` window holding the chair role. Every
+agent runtime receives chaired assignments through one local bus and never
+addresses another agent 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
@@ -47,6 +53,7 @@ import sys
 
 GUIONES = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, GUIONES)
+import busca  # noqa: E402  the one disk scanner: repos, worktrees, documents
 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
@@ -55,6 +62,8 @@ 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
+import workspace  # noqa: E402  agents, their workspaces, mounts and skills
+import atajos  # noqa: E402  the city's door on the desktop
 
 # 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
@@ -77,7 +86,7 @@ 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
+PASOS = 7
 
 
 def instala(programa, formulas):
@@ -274,17 +283,11 @@ def donde_viven_las_fichas(usuario=""):
 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.
+    `busca` 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
+    return busca.repos()
 
 
 def ultimo_commit(ruta):
@@ -307,22 +310,32 @@ def mios(usuario, correo, repos):
     return marcados
 
 
-def escribe_ficha(ruta, usuario, rol, repos, objetivo=None, ciudad="", repo_roles=None):
+def escribe_ficha(ruta, usuario, rol, agentes=None, objetivo=None, ciudad=""):
     """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.
+    One shape: a roster of agents. `repos:` remains a card format this product
+    READS forever — every old city keeps working — but nothing writes it any
+    more, because two writers of one fact is how the terminal and the web ended
+    up producing different cities for the same city. The keys come from
+    `workspace.claves_de_roster`, the same ones the Hall's endpoints write.
+
+    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)
+    agentes = list(agentes or [])
+    identidad = [
+        f"{clave}: {valor}"
+        for clave, valor in workspace.claves_de_roster(agentes).items()
+        if valor or clave == "agents"
+    ]
     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()),
+        *identidad,
         f"goals_defined: {'true' if objetivo else 'false'}",
         "---",
     ]
@@ -334,22 +347,21 @@ def escribe_ficha(ruta, usuario, rol, repos, objetivo=None, ciudad="", repo_role
         "",
         card.linea_rol(rol, oficio),
         "",
-        "## Repos",
+        "## Agents",
         "",
     ]
-    if repos:
-        cuerpo += [
-            "Answers for: " + ", ".join(f"`{r}`" for r in sorted(repos)) + ".",
-            "",
-            "Change them with `./bin/seat --repos`.",
-        ]
+    if agentes:
+        for a in agentes:
+            monta = f"{len(a['mounts'])} mount{'s' if len(a['mounts']) != 1 else ''}"
+            cuerpo.append(f"- `{a['nombre']}` — {a['clase']}, role {a['rol']}, {monta}.")
+        cuerpo += ["", "Change the roster with `./bin/seat --agents`."]
     else:
         cuerpo += [
-            "Owns no folders, on purpose. This role holds a property of "
+            "No agents yet, 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`.",
+            "If that is wrong: `./bin/seat --agents`.",
         ]
     cuerpo += ["", "## Current goals", ""]
 
@@ -822,7 +834,7 @@ def clona(dueno, faltan, destino):
             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)
+    busca.lugares(refrescar=True)
     return puestas
 
 
@@ -923,6 +935,260 @@ def elige_repos(usuario, ya_marcados):
     return elegidos, rutas
 
 
+def catalogo_de_repos(usuario):
+    """The repo rows to offer, resolved ONCE for the whole roster.
+
+    The old wizard asked "which folders are yours?" a single time and made one
+    agent per tick. A roster asks per agent instead, and asking GitHub — or
+    re-walking the disk — once per agent would be both slow and rude. So the
+    source question happens once and every agent picks from the same rows.
+
+    Returns (rows, paths-by-name, github-owner) or None when the person quit.
+    """
+    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":
+        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) or []
+    filas.sort(key=lambda f: f[2] or "", reverse=True)
+    mios_ahora = mios(usuario, correo, [(n, r) for n, r, _, _ in filas if r])
+    return {
+        "filas": filas,
+        "rutas": {n: r for n, r, _, _ in filas if r},
+        "dueno": dueno,
+        "mios": mios_ahora,
+    }
+
+
+def pregunta_montajes(nombre, catalogo, sugeridos=()):
+    """What one agent works on: any number of repos, plus any folders.
+
+    This is the shape the old wizard could not express. An agent is not "a
+    repo": it may answer for three services and a folder of documents, or for
+    documents alone with no git anywhere. Both are asked here, and none is
+    mandatory — an agent may start empty and mount later.
+
+    Returns the list of mount sources (paths, or repo names not cloned yet), or
+    None when the person quit.
+    """
+    fuentes = []
+    filas = catalogo["filas"] if catalogo else []
+    if filas:
+        ops = []
+        for n, ruta, cuando, _ in filas:
+            donde = ruta.replace(os.path.expanduser("~"), "~") if ruta else "· not cloned here"
+            ops.append((n, n, f"{cuando or '—'}  {donde}"))
+        elegidos = ui.elige(
+            f"Which repositories does {nombre} work on?",
+            ops,
+            marcadas=set(sugeridos),
+            minimo=0,
+            step=3,
+            of=PASOS,
+            ayuda="As many as this agent answers for — one, three, or none. "
+            "They are mounted inside its workspace, not turned into separate "
+            "agents. Nothing ticked is a valid answer.",
+        )
+        if elegidos is None:
+            return None
+        rutas_repo = dict(catalogo["rutas"])
+        if catalogo["dueno"]:
+            faltan = [n for n in elegidos if n not in rutas_repo]
+            rutas_repo.update(
+                clona(
+                    catalogo["dueno"],
+                    faltan,
+                    os.environ.get("CITY_CODE_DIR", os.path.expanduser("~/codigo")),
+                )
+            )
+        fuentes += [rutas_repo.get(n, n) for n in sorted(elegidos)]
+
+    # And the work that is not a repo at all — the reason this model exists.
+    while True:
+        carpeta = ui.pide(
+            f"A folder of documents for {nombre} (empty when done)",
+            "",
+            ayuda="Anything on this disk: a handbook, a drive folder, case "
+            "files. It is mounted the same way a repo is, and needs no git.",
+        )
+        if carpeta is None:
+            return None
+        carpeta = carpeta.strip()
+        if not carpeta:
+            return fuentes
+        destino = os.path.expanduser(carpeta)
+        if not os.path.isdir(destino):
+            print(f"  ↳ there is no folder at {destino}")
+            continue
+        fuentes.append(destino)
+
+
+def pregunta_clase(nombre):
+    """What kind of work this agent does — what makes its house grow."""
+    return ui.una(
+        f"What kind of work does {nombre} do?",
+        [
+            ("code", "Code", "grows with merged pull requests; mounts repos and worktrees"),
+            ("knowledge", "Knowledge", "grows with documents; needs no git at all"),
+            ("coordinator", "Coordinator", "grows with recorded decisions"),
+        ],
+        3,
+        PASOS,
+        ayuda="This is not a permission. It decides how this agent's work is "
+        "counted and how its house grows on the map — shipping code, keeping "
+        "knowledge, or deciding.",
+    )
+
+
+def pregunta_skills_de_agente(datos, nombre, slug, runtime):
+    """Offer to install skills into this agent's own home, for the engine that
+    reads them.
+
+    Skills are the Claude runtime's format. Offering them for a window running
+    Codex would be selling something that engine ignores, so the question is
+    only asked where the answer means anything — and it says so.
+    """
+    if runtime and runtime != "claude":
+        print(f"  {nombre} runs {runtime}, which ignores skills — none offered.")
+        return []
+    puestas = []
+    while True:
+        origen = ui.pide(
+            f"A skill folder or .zip for {nombre} (empty when done)",
+            "",
+            ayuda="Installed into this agent's own home, and read by Claude in "
+            "its window. Recognition elsewhere stays read-only: this is the one "
+            "place Agents City writes a skill, because you asked it to.",
+        )
+        if origen is None or not str(origen).strip():
+            return puestas
+        puesta, mal = workspace.instala_skill(datos, slug, str(origen).strip())
+        if mal:
+            print(f"  ↳ {mal}")
+            continue
+        puestas.append(puesta)
+        print(f"  ↳ {puesta} installed for {nombre}.")
+
+
+def pregunta_un_agente(datos, dominio, catalogo, ya_puestos):
+    """One agent, whole: who it is, what it does, what it works on, what runs
+    it, and the skills it starts with. Returns the agent dict, or None on quit.
+    """
+    def libre(valor):
+        limpio = card.ventana(str(valor or "").strip())
+        if not str(valor or "").strip():
+            return "an agent needs a name"
+        if limpio in {card.ventana(n) for n in ya_puestos}:
+            return f"{limpio} is already an agent in this city"
+        return ""
+
+    nombre = ui.pide(
+        "The agent's name",
+        "",
+        validar=libre,
+        ayuda="How you will call it — in its tmux window, on the map, and on "
+        "the bus. A person's name, a service, a team: whatever you would say "
+        "out loud when you ask it for something.",
+    )
+    if nombre is None or not nombre.strip():
+        return None
+    nombre = nombre.strip()
+    slug = card.ventana(nombre)
+
+    clase = pregunta_clase(nombre)
+    if clase is None:
+        return None
+    rol = pregunta_rol_agente(nombre, dominio)
+    if rol is None:
+        return None
+    montajes = pregunta_montajes(nombre, catalogo)
+    if montajes is None:
+        return None
+    # The engine, the model and the effort, asked where they belong: on the
+    # agent that will run them. They used to be a separate late step about
+    # "windows", which is the old repo-shaped vocabulary.
+    motor = motor_de_ventana(slug)
+    if motor is None:
+        return None
+    workspace.crea_workspace(datos, slug)
+    skills = pregunta_skills_de_agente(datos, nombre, slug, motor.get(f"runs.{slug}", ""))
+    return {
+        "nombre": nombre,
+        "slug": slug,
+        "clase": clase,
+        "rol": rol,
+        "mounts": montajes,
+        "motor": motor,
+        "skills": skills,
+    }
+
+
+def pregunta_agentes(usuario, dominio, datos, actuales=()):
+    """The roster, built one agent at a time until the city is complete.
+
+    The city is not "your folders". It is the people in it, and each of them is
+    asked for in full — name, kind, role, everything it works on, its engine and
+    its skills — before the next one is offered. The loop ends when you say the
+    city is complete, which is the only thing that ends it.
+    """
+    agentes = list(actuales)
+    catalogo = None
+    while True:
+        if agentes:
+            hecho = ui.una(
+                f"{len(agentes)} agent{'s' if len(agentes) != 1 else ''} so far: "
+                + ", ".join(a["nombre"] for a in agentes),
+                [
+                    ("otro", "Add another agent", "one more member of this city"),
+                    ("fin", "That is the whole city", "the roster is complete"),
+                ],
+                3,
+                PASOS,
+                ayuda="A city keeps working as you add to it — this is not your "
+                "last chance. Change the roster any time with "
+                "./bin/seat --agents.",
+            )
+            if hecho is None:
+                return None
+            if hecho != "otro":
+                return agentes
+        elif not ui.pantalla(
+            "Now the people in this city",
+            "A city is its agents, and each one is asked for in full: who it "
+            "is, what kind of work it does, its role, everything it works on, "
+            "the engine that runs it and the skills it starts with.\n\n"
+            "An agent is not a repository. It can answer for three services "
+            "and a folder of documents at once, or for documents alone with no "
+            "git anywhere — that is why this asks agent by agent instead of "
+            "handing you a list of folders to tick.\n\n"
+            "You will be asked for another after each one, until you say the "
+            "city is complete. None is a valid answer too: a seat with no "
+            "agents is a city that reaches others over roads.",
+            3,
+            PASOS,
+            "enter to add the first · q for a city with no agents yet",
+        ):
+            return agentes
+        if catalogo is None:
+            catalogo = catalogo_de_repos(usuario)
+            if catalogo is None:
+                return None
+        nuevo = pregunta_un_agente(datos, dominio, catalogo, [a["nombre"] for a in agentes])
+        if nuevo is None:
+            # Backing out of one agent leaves the roster as it was, rather than
+            # throwing away everybody who was already described.
+            if not agentes:
+                return agentes
+            continue
+        agentes.append(nuevo)
+
+
 def dominio_configurado(a, nueva, datos):
     """Resolve question one, including the explicit CLI non-interactive path."""
     dominio_actual = domains.de_ciudad(datos)
@@ -940,7 +1206,7 @@ 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
+    solo_otro_ajuste = a.goal 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]
@@ -978,18 +1244,58 @@ def pregunta_seat_yolo(datos):
     return True
 
 
+def pregunta_atajo(datos, nueva):
+    """Question seven: whether this city gets a door on the desktop.
+
+    A tool you have to remember how to start is a tool you stop starting. The
+    shortcut runs the same command a person would type, so it adds a way in
+    without adding a second implementation of anything. Only offered where a
+    desktop exists, and only on a new city — nobody wants this asked weekly.
+    """
+    if not nueva or not atajos.escritorio():
+        return True
+    eleccion = ui.una(
+        "Put this city on your desktop?",
+        [
+            (
+                "si",
+                "Yes, with its icon",
+                "double-click it and the city opens, tmux session and all",
+            ),
+            ("no", "No thanks", "you can add it later: agents-city shortcut"),
+        ],
+        7,
+        PASOS,
+        ayuda="A real desktop shortcut carrying the city's name and a colour "
+        "drawn from its own identity. It runs `agents-city seat --city …` — "
+        "the same line you would type. Remove it any time: "
+        "agents-city shortcut --remove.",
+    )
+    if eleccion is None:
+        return False
+    if eleccion == "si":
+        ruta, mal = atajos.crea(datos)
+        print(f"  {mal}" if mal else f"  On your desktop: {ruta}")
+    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)
+    """Whether this invocation re-asks any of the seven questions."""
+    return bool(nueva or a.agent_roles or a.goal or a.domain or a.role or a.engines)
+
 
+def pregunta_runtime(a, nueva, datos):
+    """Questions five and six: what runs in the chair's own window, and whether
+    it asks permission. None means the person quit; {} means neither question
+    was due this invocation.
 
-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."""
+    Every other window's engine belongs to its agent and is asked while that
+    agent is being created — a late "what runs in each window?" pass was the
+    old repo-shaped vocabulary talking.
+    """
     if not (nueva or a.engines):
         return {}
-    motores = pregunta_motores(elegidos)
+    motores = pregunta_motores([])
     if motores is None or not pregunta_seat_yolo(datos):
         return None
     return motores
@@ -1010,7 +1316,7 @@ def ajusta_seat_yolo(a, datos, nueva):
 
 
 def configura(a, ficha, nueva, datos, usuario):
-    """The six questions, or the setting being re-asked. False means quit."""
+    """The seven questions, or the setting being re-asked. False means quit."""
     previo = open(ficha).read() if not nueva else ""
 
     def campo(k, defecto=""):
@@ -1025,25 +1331,14 @@ def configura(a, ficha, nueva, datos, usuario):
     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:
+    # 3. The roster, one agent at a time — each asked for in full.
+    plantilla = nueva or a.agent_roles
+    if plantilla:
+        roster = pregunta_agentes(usuario, dominio, datos, agentes_de_ficha(ficha, datos))
+        if roster is None:
             return False
     else:
-        roles_repos = card.normaliza_roles_repos(elegidos, actuales_roles)
+        roster = agentes_de_ficha(ficha, datos)
 
     # 4. The goal, which is the one thing a round cannot work without.
     objetivo = None
@@ -1052,11 +1347,16 @@ def configura(a, ficha, nueva, datos, 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)
+    # 5 and 6. The chair's own engine, and whether it asks permission. Every
+    # other engine was decided on its own agent, where it belongs.
+    motores = pregunta_runtime(a, nueva, datos)
     if motores is None:
         return False
 
+    # 7. The door on the desktop, offered once, when the city is new.
+    if not pregunta_atajo(datos, nueva):
+        return False
+
     escribe_cambios(
         ficha,
         nueva,
@@ -1064,17 +1364,57 @@ def configura(a, ficha, nueva, datos, usuario):
         usuario,
         dominio,
         rol,
-        elegidos,
-        roles_repos,
+        roster,
         objetivo,
         a.goal,
         motores,
-        cambia_roles_repos,
+        plantilla,
     )
-    resume(datos, usuario, dominio, rol, elegidos, roles_repos, objetivo)
+    resume(datos, usuario, dominio, rol, roster, objetivo)
     return True
 
 
+def agentes_de_ficha(ficha, datos):
+    """The roster already on a card, in the wizard's own shape.
+
+    Reads through `workspace.agentes`, so a legacy `repos:` card arrives as the
+    agents it always was — one per repo, each mounting itself — and re-running
+    the wizard over it upgrades rather than discards.
+    """
+    try:
+        texto = card.lee(ficha).get("texto") or ""
+    except OSError:
+        return []
+    try:
+        vivos = workspace.agentes(texto, datos)
+    except ValueError:
+        return []
+    return [workspace.como_ficha(a) for a in vivos]
+
+
+# What a roster looks like on a card is workspace.py's fact, not the wizard's:
+# the Hall writes the same keys from a POST, and two writers of one shape drift.
+claves_de_agentes = workspace.claves_de_roster
+
+
+def materializa_agentes(datos, ficha):
+    """Give every agent on the card its workspace and its mounts on disk.
+
+    The card is the source of truth, so this reads it back rather than trusting
+    the answers in memory: what the launcher and the cage will see is exactly
+    what gets built here."""
+    try:
+        texto = card.lee(ficha).get("texto") or ""
+        vivos = workspace.agentes(texto, datos)
+    except (OSError, ValueError):
+        return []
+    hechos = []
+    for a in vivos:
+        destinos = workspace.sincroniza(a, datos)
+        hechos.append((a.nombre, len(destinos)))
+    return hechos
+
+
 def escribe_cambios(
     ficha,
     nueva,
@@ -1082,26 +1422,17 @@ def escribe_cambios(
     usuario,
     dominio,
     rol,
-    elegidos,
-    roles_repos,
+    roster,
     objetivo,
     con_goal,
     motores,
-    actualiza_roles_repos,
+    actualiza_roster,
 ):
     """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,
-        )
+        escribe_ficha(ficha, usuario, rol, roster, objetivo, cities.slug_ciudad(datos))
     else:
         card.cambia_rol(
             ficha,
@@ -1109,51 +1440,59 @@ def escribe_cambios(
             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.
+    if actualiza_roster or nueva:
+        for clave, valor in claves_de_agentes(roster).items():
+            card.pon_campo(ficha, clave, valor)
     for clave, valor in motores.items():
         card.pon_campo(ficha, clave, valor)
+    materializa_agentes(datos, ficha)
     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)
+    for rol_agente in sorted({a["rol"] for a in roster} - {"blank", rol}):
+        conocimiento += domains.materializa(datos, dominio, rol_agente)
     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."))
+    otros += sorted(
+        a["slug"] for a in roster if (a.get("motor") or {}).get(f"runs.{a['slug']}")
+    )
     if otros:
         print(f"  Windows on another engine: {', '.join(otros)} — the rest run Claude.")
 
 
-def resume(datos, usuario, dominio, rol, elegidos, roles_repos, objetivo):
+def resume(datos, usuario, dominio, rol, roster, 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:
+    if roster:
         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)
+            f"  {len(roster)} agent{'s' if len(roster) != 1 else ''} in this city — "
+            f"one window each. Change the roster with ./bin/seat --agents"
         )
-        print(f"  Support-agent roles: {resumen_roles}.")
+        for a in roster:
+            trabajo = (
+                f"{len(a['mounts'])} mount{'s' if len(a['mounts']) != 1 else ''}"
+                if a["mounts"]
+                else "nothing mounted yet"
+            )
+            extra = f", skills: {', '.join(a['skills'])}" if a.get("skills") else ""
+            print(f"    · {a['nombre']} — {a['clase']}, {roles.nombre(a['rol'])}, {trabajo}{extra}")
     else:
         print(
-            "  No support repos in this city. Its seat still opens on its own;\n"
+            "  No agents in this city yet. 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):
+        for h in escribe_suelo(datos, [a["nombre"] for a in roster], dominio):
             print(f"    · {h}")
-        if elegidos:
+        if roster:
             print(
                 f"\n  Your city is drawable now — no wizard, no account:\n"
                 f"    ./bin/city {datos.replace(os.path.expanduser('~'), '~')}"
@@ -1211,13 +1550,16 @@ def argumentos():
     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")
+    # One question, one flag. `--repos` and `--agent-roles` are the names this
+    # asked by when a repo WAS an agent; they still work, and they open the same
+    # roster, because breaking somebody's muscle memory buys nothing.
     ap.add_argument(
-        "--agent-roles",
         "--agents",
+        "--agent-roles",
+        "--repos",
         action="store_true",
         dest="agent_roles",
-        help="choose the operating role each repo agent adopts",
+        help="build the roster again, agent by agent (--repos is the old name for it)",
     )
     ap.add_argument("--goal", action="store_true", help="set your goal again")
     ap.add_argument(
@@ -1314,7 +1656,7 @@ def main():
     if hay_ajustes(a, nueva):
         if nueva:
             print(
-                f"\n  First time here. Six questions and you are in — the work "
+                f"\n  First time here. Seven 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. "