agents-city 0.1.0 → 0.2.1

package/city/web/src/hall.ts

@@ -11,6 +11,7 @@
  * ever serves this file.
  */
 
+import { Bienvenida } from './bienvenida';
 import {
   ActivityEvent,
   MAP_ACTIVITY_PROTOCOL,
@@ -63,6 +64,8 @@ interface Ciudad {
   slug?: string;
   id?: string;
   actual: boolean;
+  /** How many agents live in it. An agent belongs to exactly one city. */
+  agentes?: number;
 }
 interface Road {
   id: string;
@@ -187,6 +190,16 @@ interface DomainInfo {
   name: string;
   summary: string;
 }
+/** What a reset would do, as the server computes it — never guessed here. */
+interface Efectos {
+  city: string;
+  backup: string;
+  agents: number;
+  roads: number;
+  deliberations: number;
+  keeps: string[];
+  loses: string[];
+}
 interface RepoLocal {
   nombre: string;
   ruta: string;
@@ -263,14 +276,33 @@ const SECCIONES: Array<[string, string]> = [
   ['resumen', 'Overview'],
   ['mapa', 'The map'],
   ['puesto', 'My seat'],
-  ['barrios', 'Districts & houses'],
+  ['barrios', 'Districts'],
   ['red', 'Roads'],
   ['committee', 'Committee'],
-  ['gente', 'Agents & skills'],
+  ['gente', 'Houses'],
+  ['ciudades', 'Cities'],
 ];
 
+/** True until the person navigates: the landing section is decided once, from
+ * the state, and never yanked out from under them afterwards. */
+let primeraCarga = true;
+
 async function refresca(): Promise<void> {
   E = await api<Estado>('/api/estado');
+  if (primeraCarga) {
+    primeraCarga = false;
+    // A city with no seat or no agents has nothing to draw, and "Not drawn
+    // yet" is a dead end as a first impression. Start where the next step is.
+    const mia = E.tarjetas.find((t) => t.user === E.yo);
+    // Never land on a dead end. Three cases, in order of what the person needs:
+    //   nothing set up      -> the guide, which asks the questions
+    //   set up, no map yet  -> the overview, which says what is left and how
+    //   set up, map running -> the map, which is the point of the product
+    // Landing on the map view without a map was how "Not drawn yet" became the
+    // first thing an owner saw every single morning.
+    if (!mia || (E.agents ?? []).length === 0) SECCION = 'bienvenida';
+    else if (!E.mapa) SECCION = 'resumen';
+  }
   pinta();
   pintaAvisoDeVersion();
   pintaDemoControles();
@@ -706,22 +738,36 @@ function icono(kind: string): string {
 }
 
 function rail(): void {
-  q('#rail').innerHTML = SECCIONES.map(([id, et]) => {
-    const n =
-      id === 'gente'
-        ? String(Object.keys(E.skills).length)
-        : id === 'committee'
-          ? String(E.deliberations.length)
-          : id === 'red'
-            ? String(E.roads.length)
-            : id === 'barrios'
-              ? String(E.parcelas.length)
-              : '';
-    return `<li class="${id === SECCION ? 'aqui' : ''}" data-s="${id}">
+  // Everything above the divider belongs to ONE city — its seat, its agents,
+  // its map. Saying so here is the difference between a menu and a place: an
+  // agent's workspace and mounts live inside this city's folder, and a flat
+  // list of "Cities" and "Agents" as siblings hid that completely.
+  const cuantos = (E.agents ?? []).length;
+  q('#railCiudad').innerHTML = `<span class="railEtiqueta">you are in</span>
+    <b>${esc(E.city_name)}</b>
+    <span class="railDe">${esc(E.domain)} · ${cuantos} house${cuantos === 1 ? '' : 's'}</span>`;
+  q('#rail').innerHTML = SECCIONES.filter(([id]) => id !== 'ciudades')
+    .map(([id, et]) => {
+      const n =
+        id === 'gente'
+          ? String(Object.keys(E.skills).length)
+          : id === 'committee'
+            ? String(E.deliberations.length)
+            : id === 'red'
+              ? String(E.roads.length)
+              : id === 'barrios'
+                ? String(E.parcelas.length)
+                : '';
+      return `<li class="${id === SECCION ? 'aqui' : ''}" data-s="${id}">
       <span>${et}</span>${n ? `<span class="n">${n}</span>` : ''}</li>`;
-  }).join('');
-  todos<HTMLElement>('#rail li').forEach((li) => {
+    })
+    .join('');
+  q('#railOtras').innerHTML =
+    `<li class="${SECCION === 'ciudades' ? 'aqui' : ''}" data-s="ciudades">
+      <span>All cities</span><span class="n">${E.ciudades.length}</span></li>`;
+  todos<HTMLElement>('#rail li,#railOtras li').forEach((li) => {
     li.onclick = () => {
+      document.body.classList.remove('enGuia');
       SECCION = li.dataset.s ?? 'mapa';
       pinta();
     };
@@ -768,17 +814,185 @@ function pinta(): void {
 const VISTAS: Record<string, () => void> = {};
 
 // ── overview ─────────────────────────────────────────────────────────────────
+/** The guided first run. Built once and kept, so a half-finished answer
+ * survives a repaint. */
+let guia: Bienvenida | null = null;
+
+VISTAS.bienvenida = () => {
+  document.body.classList.add('enGuia');
+  guia ??= new Bienvenida({
+    api,
+    esc,
+    aviso: toast,
+    refresca,
+    vete: (seccion: string) => {
+      document.body.classList.remove('enGuia');
+      SECCION = seccion;
+      pinta();
+    },
+    ciudad: E.city_name,
+    yo: E.yo,
+    datos: corto(E.datos),
+  });
+  void guia.pinta(q<HTMLElement>('#lienzo'));
+};
+
+VISTAS.ciudades = () => {
+  const filas = E.ciudades
+    .map(
+      (c) => `
+      <div class="fila ${c.actual ? 'on' : ''}">
+        <span class="et">${esc(c.nombre)}${c.actual ? ' <b class="de">· open now</b>' : ''}</span>
+        <span class="de">${c.agentes ?? 0} house${(c.agentes ?? 0) === 1 ? '' : 's'} of its own</span>
+        <span class="de mono">${esc(corto(c.ruta))}</span>
+        <span style="margin-left:auto;display:flex;gap:6px">
+          ${
+            c.actual
+              ? ''
+              : `<a class="bt mini" href="?city=${encodeURIComponent(c.ruta)}">open</a>
+                 <button class="bt mini archiva" data-ciudad="${esc(c.ruta)}"
+                   data-nombre="${esc(c.nombre)}">archive</button>`
+          }
+        </span>
+      </div>`,
+    )
+    .join('');
+  q('#lienzo').innerHTML = `<div><span class="sub">cities</span>
+    <h1 style="margin-top:6px">Your cities</h1>
+    <p class="prosa" style="margin-top:8px">One person, several autonomous cities: each has
+    its own identity, domain, chair, <b>its own houses</b> and its own roads. A house is not
+    shared — it stands inside the city that owns it, with its workspace and mounts under that
+    city's folder — so two cities can each have a <code class="mono">docs</code> house and
+    they are two different workers. They share nothing unless you build a road between
+    them.</p></div>
+    <div class="lista"><div class="filas">${filas}</div></div>
+    <div class="campos" style="max-width:420px">
+      <div class="campo"><label>Start another city</label>
+        <input type="text" id="nuevaCiudad" placeholder="client-a, research, the book…"></div>
+      <button class="bt ppal" id="creaCiudad">Create it</button>
+    </div>
+    <div class="peligro">
+      <h3>Start this city over</h3>
+      <p class="prosa">Takes <b>${esc(E.city_name)}</b> back to its first day: no seat, no
+      agents, no committee history, no map. Your repositories and document folders are
+      <b>never touched</b> — only the city that points at them.</p>
+      <button class="bt malo" id="reiniciaCiudad">Start over…</button>
+    </div>
+    <p class="pista">Archiving <b>moves</b> a city into
+    <code class="mono">.backups/</code> — nothing is deleted, and you can bring it back with
+    <code class="mono">mv</code>. The city you are standing in, and the last one you own,
+    cannot be archived.</p>`;
+  enlaza();
+  const campo = q<HTMLInputElement>('#nuevaCiudad');
+  q<HTMLButtonElement>('#creaCiudad').onclick = async () => {
+    const nombre = campo.value.trim();
+    if (!nombre) {
+      toast('Give it a name', true);
+      return;
+    }
+    const r = await api<Respuesta>('/api/ciudades', {
+      method: 'POST',
+      body: JSON.stringify({ name: nombre }),
+    });
+    if (!r.ok) {
+      toast(r.error ?? 'Could not create it', true);
+      return;
+    }
+    toast(`${nombre} created`);
+    await refresca();
+  };
+  const reiniciar = document.getElementById('reiniciaCiudad');
+  if (reiniciar)
+    reiniciar.onclick = async () => {
+      // Two round-trips on purpose: the first asks the server what this would
+      // actually do, and the person reads it before typing anything. "Are you
+      // sure?" is not information; a list of what disappears is.
+      const previa = await api<{ preview?: Efectos; error?: string }>('/api/ciudad-reinicia', {
+        method: 'POST',
+        body: '{}',
+      });
+      if (!previa.preview) {
+        toast(previa.error ?? 'Could not read what a reset would do', true);
+        return;
+      }
+      const p = previa.preview;
+      const texto =
+        `Start over ${p.city}?\n\nYou lose:\n` +
+        p.loses.map((l) => `  · ${l}`).join('\n') +
+        `\n\nRight now that is ${p.agents} agent(s), ${p.roads} road(s) and ` +
+        `${p.deliberations} committee act(s).\n\nYou keep:\n` +
+        p.keeps.map((l) => `  · ${l}`).join('\n') +
+        `\n\nType the city's name to confirm:`;
+      const escrito = window.prompt(texto, '');
+      if (escrito === null) return;
+      if (escrito.trim() !== p.city) {
+        toast('That is not the name — nothing was changed', true);
+        return;
+      }
+      const r = await api<{ ok?: boolean; backup?: string; error?: string }>(
+        '/api/ciudad-reinicia',
+        { method: 'POST', body: JSON.stringify({ confirm: p.city }) },
+      );
+      if (!r.ok) {
+        toast(r.error ?? 'Could not reset it', true);
+        return;
+      }
+      toast(`${p.city} starts over — the old one is at ${r.backup ?? 'its backup'}`);
+      primeraCarga = true; // land wherever a fresh city should land: the guide
+      await refresca();
+    };
+  todos<HTMLButtonElement>('.archiva').forEach((boton) => {
+    boton.onclick = async () => {
+      const nombre = boton.dataset.nombre ?? '';
+      if (!window.confirm(`Archive ${nombre}? It moves into .backups — nothing is deleted.`))
+        return;
+      const r = await api<{ ok?: boolean; backup?: string; error?: string }>(
+        '/api/ciudad-archiva',
+        { method: 'POST', body: JSON.stringify({ city: boton.dataset.ciudad ?? '' }) },
+      );
+      if (!r.ok) {
+        toast(r.error ?? 'Could not archive it', true);
+        return;
+      }
+      toast(`${nombre} archived — it is in ${r.backup ?? '.backups'}`);
+      await refresca();
+    };
+  });
+};
+
 VISTAS.resumen = () => {
   const mia = E.tarjetas.find((t) => t.user === E.yo);
   const sinUnidad = E.parcelas.filter((p) => p.unidad === 'none' || p.unidad === 'mine').length;
+  const agentes = E.agents ?? [];
+  // The order somebody actually does it in: take the chair, say who works
+  // here, say what for. The old list asked for "folders" — the vocabulary of
+  // the model before agents existed — and never mentioned the roster at all,
+  // so a new city could look finished with nobody in it.
   const tareas = [
     {
       ok: !!mia,
       txt: mia
-        ? `Your card exists — you are <b>${esc(mia.agent)}</b>`
-        : 'Take your seat: role, folders, one goal',
+        ? `Your seat is taken — you are <b>${esc(mia.agent)}</b> in <b>${esc(E.domain)}</b>`
+        : 'Take your seat: the work domain and your role in it',
       ir: 'puesto',
     },
+    {
+      ok: agentes.length > 0,
+      txt:
+        agentes.length === 0
+          ? 'Build the <b>houses</b> of this city — one per worker, each whole: its kind, its role, and everything it works on'
+          : `<b>${agentes.length}</b> house${agentes.length === 1 ? '' : 's'} in this city: ${esc(
+              agentes.map((a) => a.name).join(', '),
+            )}`,
+      ir: 'gente',
+    },
+    {
+      ok: agentes.length === 0 || agentes.some((a) => (a.mounts ?? []).length),
+      txt: agentes.some((a) => (a.mounts ?? []).length)
+        ? 'Every house works on something real'
+        : 'Give a house something to work on — a repository, a worktree, a folder of documents',
+      ir: 'gente',
+    },
     {
       ok: !!(mia && mia.goals_defined),
       txt:
@@ -788,23 +1002,33 @@ VISTAS.resumen = () => {
       ir: 'puesto',
     },
     {
-      ok: E.parcelas.length > 0 && sinUnidad === 0,
+      ok: E.parcelas.length === 0 || sinUnidad === 0,
       txt:
         E.parcelas.length === 0
-          ? 'No houses yet — pick your folders and they appear'
+          ? 'Districts appear on the map once agents have houses'
           : sinUnidad
             ? `<b>${sinUnidad}</b> of ${E.parcelas.length} houses sit in no real district — assign them`
             : 'Every house has its district',
       ir: 'barrios',
     },
   ];
+  const empezando = !mia || agentes.length === 0;
   const sesionArriba = E.tmux.includes(E.sesion);
   q('#lienzo').innerHTML = `
-    <div><span class="sub">your city</span>
-      <h1 style="margin-top:6px">${esc(E.city_name)}</h1>
+    <div><span class="sub">${empezando ? 'welcome' : 'your city'}</span>
+      <h1 style="margin-top:6px">${empezando ? 'Let’s build ' + esc(E.city_name) : esc(E.city_name)}</h1>
       <p class="de mono" style="margin-top:5px">${esc(E.address)}</p>
-      <p class="prosa" style="margin-top:8px">Domain: <b>${esc(E.domain)}</b>. Growth is
-      counted with <code class="mono">${esc(E.grow || 'nothing yet')}</code>.</p></div>
+      ${
+        empezando
+          ? `<p class="prosa" style="margin-top:8px">A city is a chair and the agents behind
+             it. Two steps and it is alive: take your seat — the work domain and your role in
+             it — then add the agents, each one asked for whole: what kind of work it does,
+             its role, everything it works on, the engine that runs it and the skills it
+             starts with. Everything below is a plain file in
+             <code class="mono">${esc(corto(E.datos))}</code> you can also edit by hand.</p>`
+          : `<p class="prosa" style="margin-top:8px">Domain: <b>${esc(E.domain)}</b>. Growth is
+             counted with <code class="mono">${esc(E.grow || 'nothing yet')}</code>.</p>`
+      }</div>
     <div class="cifras">
       <div class="cifra"><b>${Object.keys(E.skills).length}</b><span>repo agents</span></div>
       <div class="cifra"><b>${E.parcelas.length}</b><span>houses</span></div>
@@ -910,12 +1134,23 @@ VISTAS.mapa = () => {
     };
     return;
   }
+  const cuantos = (E.agents ?? []).length;
   q('#lienzo').innerHTML = `<div><span class="sub">the map</span>
-    <h1 style="margin-top:6px">Not drawn yet</h1>
-    <p class="prosa" style="margin-top:8px">The map can be served independently.
-    Locally the hall runs it for you: first time bakes the front end
-    and seeds the local database, which takes about a minute.</p></div>
-    <div><button class="bt ppal" id="arrancaMapa">Draw my city</button></div>
+    <h1 style="margin-top:6px">Your city, drawn</h1>
+    <p class="prosa" style="margin-top:8px">${
+      cuantos
+        ? `<b>${cuantos}</b> agent${cuantos === 1 ? '' : 's'} live here, and the map shows
+           them as houses that grow with the work they do — with the town hall in the middle
+           when a committee is sitting, and a gate for every road out.`
+        : `The map draws one house per agent. There are none yet, so it would be an empty
+           plot — build one from <b>Houses</b> first.`
+    }</p>
+    <p class="prosa">The map is its own little server, so it is not running until you say so.
+    The first time takes about a minute: it builds the front end and seeds a local database.
+    After that it opens instantly, and it is yours — nothing is uploaded anywhere.</p></div>
+    <div><button class="bt ppal" id="arrancaMapa">${
+      cuantos ? 'Draw my city' : 'Draw it anyway'
+    }</button></div>
     <p class="cargando" id="mapaEspera" style="display:none">baking the map — first time takes a minute</p>`;
   q<HTMLButtonElement>('#arrancaMapa').onclick = async () => {
     q<HTMLButtonElement>('#arrancaMapa').disabled = true;
@@ -1511,16 +1746,22 @@ VISTAS.gente = () => {
       </div>`;
   };
 
-  q('#lienzo').innerHTML = `<div><span class="sub">agents &amp; skills</span>
-    <h1 style="margin-top:6px">One seat, the agents behind it</h1>
-    <p class="prosa" style="margin-top:8px">A city is its agents, and each one is
-    whole here: the kind of work it does, its role, everything it works on — any
-    number of repositories and document folders at once — the engine and effort
-    that run it, and the skills in its own home. Every number is real: growth
-    from what the agent actually produced, skills from live read-only
-    recognition. Changes persist to the card and apply the next time the session
-    opens.</p>
-    <button class="rpgAlta" type="button" id="altaAgente">+ Add an agent</button></div>
+  q('#lienzo').innerHTML = `<div><span class="sub">the houses of ${esc(E.city_name)}</span>
+    <h1 style="margin-top:6px">Who lives in ${esc(E.city_name)}</h1>
+    <p class="prosa" style="margin-top:8px"><b>A house is where an agent lives and works</b>,
+    and many houses are a city — it is the same thing the map draws, growing with what that
+    agent actually does. The card and the CLI call them <code class="mono">agents</code>;
+    here you see their houses.</p>
+    <p class="prosa">They belong to <b>this</b> city and only
+    to it: each one's workspace and its mounts live inside
+    <code class="mono">${esc(corto(E.datos))}/agents/</code>, so another city has its own
+    people even if you give them the same names. Every agent is whole here: the kind of work
+    it does, its role, everything it works on — any number of repositories and document
+    folders at once — the engine and effort that run it, and the skills in its own home.</p>
+    <p class="prosa">Every number is real: growth from what the agent actually produced,
+    skills from live read-only recognition. Changes persist to the card and apply the next
+    time the session opens.</p>
+    <button class="rpgAlta" type="button" id="altaAgente">+ Build a house</button></div>
     <div class="fichasRPG">
       <div class="fichaRPG rpgSeat">
         <div class="rpgCab">${caraRPG(E.avatars?.['seat'])}
@@ -1662,7 +1903,7 @@ VISTAS.gente = () => {
           toast(r.error || 'Could not add the agent', true);
           return;
         }
-        toast(`${nombre.trim()} joined this city — give it something to work on`);
+        toast(`${nombre.trim()} has a house now — give it something to work on`);
         void refresca();
       } catch (e) {
         toast(String(e), true);
@@ -1909,7 +2150,9 @@ window.addEventListener('message', (message) => {
 function temaActual(): 'light' | 'dark' {
   const elegido = document.documentElement.getAttribute('data-tema');
   if (elegido) return elegido === 'claro' ? 'light' : 'dark';
-  return window.matchMedia?.('(prefers-color-scheme: light)').matches ? 'light' : 'dark';
+  // Day is THE default, full stop: a desktop set to dark does not decide this
+  // for the owner. Only the switch does, and it is remembered.
+  return 'light';
 }
 
 function tema(): void {
@@ -1921,14 +2164,16 @@ function tema(): void {
       return ''; // a browser with site data blocked still gets a working page
     }
   })();
-  const claroDelSistema = window.matchMedia?.('(prefers-color-scheme: light)').matches ?? false;
+  const oscuroDelSistema = false; // daylight is the default; only the switch changes it
 
   const pon = (elegido: string): void => {
     const raiz = document.documentElement;
     if (elegido) raiz.setAttribute('data-tema', elegido);
     else raiz.removeAttribute('data-tema');
-    const claro = elegido ? elegido === 'claro' : claroDelSistema;
-    if (boton) boton.textContent = claro ? '☀ Day' : '☾ Night';
+    const claro = elegido ? elegido === 'claro' : !oscuroDelSistema;
+    // The button says where a click TAKES you, not where you are: a control
+    // labelled with the state you can already see is a riddle.
+    if (boton) boton.textContent = claro ? '☾ Night' : '☀ Day';
     const frame = document.querySelector<HTMLIFrameElement>('#cityMapFrame');
     frame?.contentWindow?.postMessage(
       { type: 'agents-city-map-theme/1', theme: claro ? 'light' : 'dark' },
@@ -1941,7 +2186,7 @@ function tema(): void {
     boton.onclick = () => {
       const claroAhora = document.documentElement.getAttribute('data-tema')
         ? document.documentElement.getAttribute('data-tema') === 'claro'
-        : claroDelSistema;
+        : !oscuroDelSistema;
       const elegido = claroAhora ? 'oscuro' : 'claro';
       try {
         localStorage.setItem('hall-tema', elegido);

package/package.json

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

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

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

package/plugin/channel/bus.js

@@ -20100,7 +20100,7 @@ try {
 }
 var chair = Boolean(context && context.actors[actor]?.role === "chair" && actor === "seat");
 var server = new Server(
-  { name: "agents-city-bus", version: "0.1.0" },
+  { name: "agents-city-bus", version: "0.2.1" },
   {
     capabilities: {
       ...channelEnabled ? { experimental: { "claude/channel": {} } } : {},

package/plugin/channel/bus.ts

@@ -24,7 +24,7 @@ try {
 
 const chair = Boolean(context && context.actors[actor]?.role === 'chair' && actor === 'seat');
 const server = new Server(
-  { name: 'agents-city-bus', version: '0.1.0' },
+  { name: 'agents-city-bus', version: '0.2.1' },
   {
     capabilities: {
       ...(channelEnabled ? { experimental: { 'claude/channel': {} } } : {}),

package/plugin/channel/runtime/codex.ts

@@ -67,7 +67,7 @@ export class CodexConnector implements RuntimeConnector {
       async (method, params) => this.providerRequest(method, params),
     );
     await this.rpc.request('initialize', {
-      clientInfo: { name: 'agents-city', title: 'Agents City', version: '0.1.0' },
+      clientInfo: { name: 'agents-city', title: 'Agents City', version: '0.2.1' },
       capabilities: { experimentalApi: true },
     });
     await this.rpc.notify('initialized');

package/plugin/channel/runtime-gateway.js

@@ -4894,7 +4894,7 @@ var CodexConnector = class {
       async (method, params) => this.providerRequest(method, params)
     );
     await this.rpc.request("initialize", {
-      clientInfo: { name: "agents-city", title: "Agents City", version: "0.1.0" },
+      clientInfo: { name: "agents-city", title: "Agents City", version: "0.2.1" },
       capabilities: { experimentalApi: true }
     });
     await this.rpc.notify("initialized");

package/plugin/scripts/cities.py

@@ -248,6 +248,40 @@ def crea(usuario, nombre_ciudad, usar=True):
     return _real(destino)
 
 
+def archiva(datos, usuario=''):
+    """Take one city out of use, keeping every byte of it.
+
+    Deliberately NOT a delete. A city is somebody's cards, deliberations and
+    map; a product that offers to erase that with one click will eventually
+    erase the wrong one. So the folder MOVES into `<user>/.backups/` with a
+    timestamp, the registry forgets it, and the selection falls back to another
+    city — recoverable with `mv`, which is a sentence a person can act on.
+
+    Returns the backup path. Refuses a city that is not this owner's managed
+    one, and refuses the last one standing: a city list with nothing in it is
+    not a state this product knows how to be in.
+    """
+    usuario = _slug(usuario or usuario_actual(), 'me')
+    real = _real(datos)
+    if not es_ciudad(real):
+        raise ValueError(f'{datos} is not a city')
+    if not gestionada(real, usuario):
+        raise ValueError('that city lives outside this owner\'s folder; move it by hand')
+    restantes = [c for c in lista(usuario) if _real(c['ruta']) != real]
+    if not restantes:
+        raise ValueError('this is your only city — create another one first')
+    base = os.path.join(carpeta_usuario(usuario), '.backups')
+    os.makedirs(base, mode=0o700, exist_ok=True)
+    destino, _ = _respaldo_libre(base, f'archivada-{nombre(real) or "city"}')
+    # The registry only ever held EXTERNAL cities — a managed one is found by
+    # walking the owner's folder, so moving it out is the whole removal.
+    seleccionada = _real(actual(usuario, crear=False) or '')
+    shutil.move(real, destino)
+    if seleccionada == real:
+        selecciona(usuario, restantes[0]['ruta'])
+    return destino
+
+
 def _registro_para(usuario):
     try:
         lineas = [l.strip() for l in open(REGISTRO, encoding='utf-8') if l.strip()]

package/plugin/scripts/reset.py

@@ -151,28 +151,64 @@ def reinicia(datos, usuario="", dry_run=False):
     return ctx["backup"]
 
 
+def _resuelve_todas(pedidas, usuario):
+    """Every requested city as a path, or (None, complaint).
+
+    `all` means every managed city this owner has. Names resolve one by one and
+    a single unknown name aborts the WHOLE run: resetting three of four cities
+    and then stopping on a typo is the worst possible outcome of a destructive
+    command, so nothing starts until every name is known.
+    """
+    if len(pedidas) == 1 and pedidas[0].lower() == "all":
+        todas = [c["ruta"] for c in cities.lista(usuario)]
+        if not todas:
+            return None, "there are no cities here to reset"
+        return todas, ""
+    fuera, desconocidas = [], []
+    for nombre in pedidas:
+        datos = cities.resuelve(nombre, usuario)
+        if datos:
+            if datos not in fuera:
+                fuera.append(datos)
+        else:
+            desconocidas.append(nombre)
+    if desconocidas:
+        conocidas = ", ".join(c["slug"] for c in cities.lista(usuario)) or "none"
+        return None, (f"no city called {', '.join(repr(d) for d in desconocidas)}. "
+                      f"Known here: {conocidas}. Nothing was reset.")
+    return fuera, ""
+
+
 def main():
     ap = argparse.ArgumentParser(
-        description="Reset one city to onboarding; repos stay untouched and data is backed up"
+        description="Reset cities to onboarding; repos stay untouched and data is backed up"
     )
-    ap.add_argument("city", help="city name or path (required)")
+    ap.add_argument("city", nargs="+",
+                    help="one or more city names or paths, space separated — or `all`")
     ap.add_argument("--dry-run", action="store_true", help="show every effect, change nothing")
     a = ap.parse_args()
     usuario = cities.usuario_actual()
-    datos = cities.resuelve(a.city, usuario)
-    if not datos:
-        conocidas = ", ".join(c["slug"] for c in cities.lista(usuario)) or "none"
-        print(f"  No city called {a.city!r}. Known here: {conocidas}.", file=sys.stderr)
-        return 1
-    try:
-        backup = reinicia(datos, usuario, a.dry_run)
-    except ValueError as e:
-        print(f"  {e}", file=sys.stderr)
+    objetivo, queja = _resuelve_todas(a.city, usuario)
+    if not objetivo:
+        print(f"  {queja}", file=sys.stderr)
         return 1
+    # More than one city at once is a bigger gesture than the command's name
+    # suggests, so it says out loud what it is about to do before doing it.
+    if len(objetivo) > 1 and not a.dry_run:
+        print(f"  Resetting {len(objetivo)} cities: "
+              f"{', '.join(cities.slug_ciudad(d) for d in objetivo)}")
+    for datos in objetivo:
+        try:
+            backup = reinicia(datos, usuario, a.dry_run)
+        except ValueError as e:
+            print(f"  {cities.slug_ciudad(datos)}: {e}", file=sys.stderr)
+            return 1
+        if not a.dry_run:
+            corto = backup.replace(os.path.expanduser("~"), "~")
+            print(f"  City `{cities.slug_ciudad(datos)}` reset. Recovery copy: {corto}")
     if not a.dry_run:
-        corto = backup.replace(os.path.expanduser("~"), "~")
-        print(f"  City `{cities.slug_ciudad(datos)}` reset. Recovery copy: {corto}")
-        print(f"  Run `agents-city seat --city {cities.slug_ciudad(datos)}` for onboarding.")
+        primera = cities.slug_ciudad(objetivo[0])
+        print(f"  Run `agents-city seat --city {primera}` for onboarding.")
     return 0