@getparallel/parx 0.4.3 → 0.5.0

package/CHANGELOG.md

@@ -6,6 +6,21 @@ changes). Entries are generated by `npm run release` from the git history of `ap
 
 <!-- Notes written under «## Unreleased» are used as the next entry instead of the git log. -->
 
+## 0.5.0 (2026-10-18)
+
+- `/missions`: your Parallel missions in a list; pick one and open it, pause or resume it (whichever fits its state), share a read-only link (copied), see its result or what the agents did, without leaving parx. `/missions bakery` filters by title.
+- `@` names one of your Parallel apps: the menu lists the connected ones and also the ones you can connect, marked «Connect». Picking a connected app writes `@Gmail ` in the input; picking one that is not connected opens its Connect page in the browser.
+- `/templates` lists the mission templates; the one you pick is written in the input as `/mission <goal>`, for you to review and send.
+- `/connections` and `/settings` open those pages of getparallel.net in the browser (and print the link).
+- `/strength` is the same as `/model` (in parx the strength is the model: Swift, Stride or Summit).
+
+## 0.4.4 (2026-10-11)
+
+- parx always shows what it is doing: «Thinking…» from the first moment, then the real step as it happens («Reading src/app.ts…», «Searching for useAuth…», «Editing 2 files…», «Running tests…», «Writing the answer…»), with the time and the Actions. If the server takes a while, only honest phrases («Planning the steps…», «Looking at the results…», «Waiting for the server…»); the old brand phrases are gone. Same in `--lanes`, at 40 columns, with `NO_COLOR` and `--ascii`.
+- The answer is written out word by word with a soft cursor, in 2 seconds at most, and ends exactly as before (markdown, code blocks, wrapping). Only the rows that change are repainted; scrolling up while it writes does not jump. Any key shows the rest at once; `/animation off` (saved) or `--no-animation` shows answers whole, and so do pipes, CI, `--lanes` and `/report`.
+- `/new` starts truly fresh: the screen and the terminal scrollback are cleared in one go, the queue, the waiting lines and what the agent remembers are gone, and you see the welcome and the tips again, like when parx opens. Mode, model and sign-in stay. If a task is running, it asks «Stop and start new?» with buttons first.
+- `/mouse off` is remembered in the next session too (it was saved but not read back).
+
 ## 0.4.3 (2026-10-11)
 
 - Each permission mode has its own colour, from least to most freedom: Read only teal, Ask violet, Auto orange, Bypass red. It shows in the status row, the `/mode` menu, the `/mode` confirmation, `/help` and the `╱╱` input marker; bash mode keeps its amber.

package/README.md

@@ -93,27 +93,47 @@ when it asks first:
 ## Inside a session
 
 The input sits at the bottom from the start; the status lives in one place, the row under the rail:
-the mode and the model at rest; while it works, what it is doing in plain words («Reading 3 files»,
-«Running tests», or «Tracing the route…» while it plans), the time and the Actions so far, with a
-small rail animation (a dot along the route, a train on the track, a sleeper scanning the rails, the
-track being laid).
+the mode and the model at rest; while it works, it always says what it is doing right now, with a
+small rail animation in violet, the time and the Actions so far. It is never silent: «Thinking…»
+while Parallel thinks, then the real step as it happens («Reading src/app.ts…», «Searching for
+useAuth…», «Editing 2 files…», «Running tests…», «Running git status…», «Writing the answer…»). If
+the server takes a while, only what is really going on («Planning the steps…», «Looking at the
+results…», «Waiting for the server…»). It works the same in `--lanes` (one row per lane), at 40
+columns, with `NO_COLOR` and with `--ascii`.
+
+**The answer is written out**, word by word, with a soft cursor, in 2 seconds at most (long answers
+go faster). It is laid out whole first, so markdown and code blocks end exactly as if they had
+appeared at once, and scrolling up while it writes does not move what you are reading. Any key shows
+the rest at once. `/animation off` (saved) or `--no-animation` shows answers whole; without a
+terminal (a pipe, CI), in `--lanes` and in `/report` they are always whole.
 
 Type `/` for the commands; the menu filters as you type, ↑ ↓ move, Tab or Enter pick, Esc closes.
 
 | Command | What it does |
 | --- | --- |
 | `/mode` | Ask, Auto, Read only or Bypass |
-| `/model` | Swift, Stride or Summit |
+| `/model` (or `/strength`) | Swift, Stride or Summit |
 | `/folder <path>` | let parx work in another folder |
 | `/lanes` | 2 or 3 tasks at once, each in its own lane, all moving together |
 | `/mission [goal]` | turn the work into a Parallel mission that keeps running on Parallel’s servers after you close the terminal; phone notification when it is done |
+| `/missions [filter]` | your missions; pick one and open it, pause or resume it, share a read-only link (copied), see its result or its activity, right here |
 | `/inbox` | what your missions are waiting for (approvals, proposed changes, your steps), as buttons; what you pick takes effect like on the web |
+| `/templates` | pick a mission template; it is written in the input as `/mission <goal>` for you to review and send |
+| `/connections`, `/settings` | open those pages of getparallel.net in the browser (the link is printed too) |
 | `/report` | a plain-language summary of what was done, copied to the clipboard for an email or WhatsApp |
 | `/teach` | class mode: explains each step as it codes, like a teacher |
-| `/undo`, `/new`, `/balance`, `/log`, `/help`, `/exit` | the usual |
+| `/new` | a clean conversation, as if you had just opened parx: the screen, the terminal scrollback, the queue and what the agent remembers are cleared (mode, model and sign-in stay). If a task is running it asks «Stop and start new?» first |
+| `/undo`, `/balance`, `/log`, `/help`, `/exit` | the usual |
 | `/notify` on, off | desktop notifications |
 | `/tips` on, off | the welcome tips |
 | `/mouse` on, off | clicks and wheel inside parx (saved; `--no-mouse` for one session) |
+| `/animation` on, off | answers written out as they arrive, or whole (saved; `--no-animation` for one session) |
+
+**Your apps with `@`:** type `@` and a menu lists your Parallel apps, the connected ones first and
+then the ones you can connect («Connect»); it filters as you type (`@gm`), ↑ ↓ move, Tab or Enter
+pick, Esc closes. A connected app is written in the input (`@Gmail `), so a `/mission` knows which
+of your apps to use; an app that is not connected opens its Connect page in the browser, and the
+next `@` shows it connected.
 
 **Bash mode:** start the input with `!` and it turns amber with a small `bash` label; Enter runs the
 command in your shell, in the project folder, and its output streams into the conversation with the

package/dist/actividad.js

@@ -0,0 +1,131 @@
+import { capacidades, c } from "./marca.js";
+import { t } from "./textos.js";
+import { anchoDeCaracter, sinColor } from "./texto.js";
+export function elipsis() {
+    return capacidades().unicode ? '…' : '...';
+}
+export function conElipsis(texto) {
+    const s = texto.trimEnd();
+    if (!s || /(…|\.\.\.|[.!?:])$/.test(s))
+        return s;
+    return `${s}${elipsis()}`;
+}
+const AL_EMPEZAR = [
+    [0, 'trabajo.pensando'],
+    [6_000, 'trabajo.planear'],
+    [15_000, 'trabajo.sigue'],
+    [35_000, 'trabajo.servidor'],
+];
+const TRAS_HERRAMIENTAS = [
+    [0, 'trabajo.pensando'],
+    [5_000, 'trabajo.resultados'],
+    [11_000, 'trabajo.siguiente'],
+    [20_000, 'trabajo.sigue'],
+    [40_000, 'trabajo.servidor'],
+];
+export function fraseDeEspera(ms, trasHerramientas = false) {
+    const tabla = trasHerramientas ? TRAS_HERRAMIENTAS : AL_EMPEZAR;
+    let clave = tabla[0][1];
+    for (const [desde, k] of tabla)
+        if (Math.max(0, ms) >= desde)
+            clave = k;
+    return conElipsis(t(clave));
+}
+export const CARACTERES_POR_SEGUNDO = 110;
+export const MS_MAX_RESPUESTA = 2000;
+export const MS_MAX_INTERMEDIO = 900;
+export const MS_POR_FOTOGRAMA = 33;
+export function duracionDeRevelado(caracteres, maxMs = MS_MAX_RESPUESTA) {
+    if (caracteres <= 0)
+        return 0;
+    return Math.round(Math.min(maxMs, Math.max(160, (caracteres / CARACTERES_POR_SEGUNDO) * 1000)));
+}
+export function caracteresVisibles(total, ms, duracion) {
+    if (duracion <= 0 || ms >= duracion)
+        return total;
+    return Math.max(0, Math.min(total, Math.floor((total * Math.max(0, ms)) / duracion)));
+}
+export function cursorEncendido(ms) {
+    return Math.floor(Math.max(0, ms) / 500) % 2 === 0;
+}
+export function simboloDeCursor() {
+    return c.violeta(capacidades().unicode ? '▍' : '_');
+}
+export function caracteresDe(lineas) {
+    let n = 0;
+    for (const l of lineas)
+        n += anchoVisible(l);
+    return n;
+}
+function anchoVisible(l) {
+    let n = 0;
+    for (const ch of sinColor(l))
+        n += anchoDeCaracter(ch);
+    return n;
+}
+const ESCAPE = /\x1b\[[0-9;?]*[ -/]*[@-~]/y;
+export function cortarVisible(linea, n) {
+    if (n <= 0)
+        return '';
+    let out = '';
+    let w = 0;
+    let color = false;
+    let i = 0;
+    while (i < linea.length) {
+        if (linea[i] === '\x1b') {
+            ESCAPE.lastIndex = i;
+            const m = ESCAPE.exec(linea);
+            if (m) {
+                out += m[0];
+                color = true;
+                i += m[0].length;
+                continue;
+            }
+        }
+        const ch = String.fromCodePoint(linea.codePointAt(i));
+        const cw = anchoDeCaracter(ch);
+        if (w + cw > n)
+            return `${out}${color ? '\x1b[0m' : ''}`;
+        out += ch;
+        w += cw;
+        i += ch.length;
+    }
+    return out;
+}
+export function revelarLineas(lineas, n, cursor, ancho = Infinity) {
+    const total = caracteresDe(lineas);
+    if (n >= total)
+        return cursor ? conCursor([...lineas], cursor, ancho) : [...lineas];
+    const out = [];
+    let quedan = Math.max(0, n);
+    for (const l of lineas) {
+        const w = anchoVisible(l);
+        if (quedan >= w) {
+            out.push(l);
+            quedan -= w;
+            continue;
+        }
+        const plano = Array.from(sinColor(l));
+        let cols = 0;
+        let k = 0;
+        while (k < plano.length && cols < quedan)
+            cols += anchoDeCaracter(plano[k++]);
+        while (k < plano.length && plano[k] !== ' ')
+            cols += anchoDeCaracter(plano[k++]);
+        const parte = cortarVisible(l, cols);
+        out.push(sinColor(parte).trim() ? parte : '');
+        break;
+    }
+    while (out.length > 1 && out[out.length - 1] === '' && lineas[out.length - 1] !== '')
+        out.pop();
+    return cursor ? conCursor(out, cursor, ancho) : out;
+}
+function conCursor(lineas, cursor, ancho) {
+    if (!lineas.length)
+        return [cursor];
+    const i = lineas.length - 1;
+    const l = lineas[i];
+    if (anchoVisible(l) + 1 < ancho)
+        lineas[i] = `${l.replace(/\s+$/, '')}${anchoVisible(l) ? ' ' : ''}${cursor}`;
+    return lineas;
+}

package/dist/agente.js

@@ -153,29 +153,31 @@ export async function hacerTarea(s, pedido, señal, imagenes = []) {
             disponibles = r.acciones.disponibles;
             pantalla.progreso(acciones);
             registro.apuntar('turno', { tarea, vuelta, acciones });
-            const llamadas = [];
+            const llamadas = r.salida.filter((i) => i.type === 'function_call');
             for (const item of r.salida) {
                 s.conversacion.push(item);
                 if (item.type === 'message') {
                     const texto = textoDeMensaje(item).trim();
                     if (texto) {
                         respuesta = texto;
+                        pantalla.espera(t('hace.respuesta'), 'tendido', true);
                         pantalla.escribir();
-                        pantalla.texto(texto);
+                        await pantalla.textoAnimado(texto, { intermedio: llamadas.length > 0 });
                         pantalla.escribir();
+                        pantalla.espera(null);
                     }
                 }
-                else if (item.type === 'function_call')
-                    llamadas.push(item);
             }
             if (!llamadas.length)
                 break;
-            const etiqueta = etiquetaDeTanda(llamadas.map((l) => ({ name: String(l.name ?? ''), arguments: String(l.arguments ?? '{}') })));
-            if (etiqueta)
-                pantalla.espera(etiqueta.texto, etiqueta.anim, false);
-            for (const ll of llamadas) {
+            const todas = llamadas.map((l) => ({ name: String(l.name ?? ''), arguments: String(l.arguments ?? '{}') }));
+            for (let i = 0; i < llamadas.length; i++) {
+                const ll = llamadas[i];
                 if (señal.aborted)
                     throw new ErrorDeParallel('interrumpido');
+                const etiqueta = etiquetaDeTanda(grupoDesde(todas, i));
+                if (etiqueta && empiezaGrupo(todas, i))
+                    pantalla.espera(etiqueta.texto, etiqueta.anim, false);
                 const salida = await ejecutarHerramienta(String(ll.name ?? ''), String(ll.arguments ?? '{}'), s.ctx);
                 s.conversacion.push({ type: 'function_call_output', call_id: ll.call_id, output: salida });
             }
@@ -209,6 +211,31 @@ export async function hacerTarea(s, pedido, señal, imagenes = []) {
     pantalla.cierre(`${t('estado.hecho')}${sep}${c.gris(textoDeAcciones(acciones))}${sep}${c.gris(duracion(ms))}`);
     return true;
 }
+function familia(nombre) {
+    if (nombre === 'write_file' || nombre === 'edit_file')
+        return 'cambio';
+    if (nombre === 'read_file' || nombre === 'search' || nombre === 'list_files')
+        return nombre;
+    return null;
+}
+export function grupoDesde(llamadas, i) {
+    const actual = llamadas[i];
+    if (!actual)
+        return [];
+    const f = familia(actual.name);
+    if (!f)
+        return [actual];
+    let j = i;
+    while (j < llamadas.length && familia(llamadas[j].name) === f)
+        j++;
+    return llamadas.slice(i, j);
+}
+export function empiezaGrupo(llamadas, i) {
+    if (i === 0)
+        return true;
+    const f = familia(llamadas[i].name);
+    return !f || f !== familia(llamadas[i - 1].name);
+}
 function cerrarLlamadasPendientes(items) {
     const respondidas = new Set(items.filter((i) => i.type === 'function_call_output').map((i) => i.call_id));
     for (const i of [...items]) {

package/dist/api.js

@@ -88,6 +88,24 @@ export function leerBandeja(servidor, token, señal) {
 export function responderBandeja(servidor, token, cuerpo, señal) {
     return llamar(servidor, '/api/terminal/bandeja', { token, cuerpo, señal, plazoMs: 60_000 });
 }
+export function leerMisiones(servidor, token, señal) {
+    return llamar(servidor, '/api/terminal/misiones', { token, señal, plazoMs: 20_000 });
+}
+export function leerMisionDeLaCuenta(servidor, token, id, señal) {
+    return llamar(servidor, `/api/terminal/misiones/${encodeURIComponent(id)}`, { token, señal, plazoMs: 20_000 });
+}
+export function cicloDeMision(servidor, token, id, accion, señal) {
+    return llamar(servidor, `/api/terminal/misiones/${encodeURIComponent(id)}/ciclo`, { token, cuerpo: { accion }, señal, plazoMs: 60_000 });
+}
+export function compartirMision(servidor, token, id, señal) {
+    return llamar(servidor, `/api/terminal/misiones/${encodeURIComponent(id)}/compartir`, { token, cuerpo: {}, señal, plazoMs: 20_000 });
+}
+export function leerConexiones(servidor, token, señal) {
+    return llamar(servidor, '/api/terminal/conexiones', { token, señal, plazoMs: 20_000 });
+}
+export function leerPlantillas(servidor, token, señal) {
+    return llamar(servidor, '/api/terminal/plantillas', { token, señal, plazoMs: 20_000 });
+}
 const CORREO_INTERNO = /@cuentas\.getparallel\.net$/i;
 export function correoVisible(correo) {
     const c = (correo ?? '').trim();

package/dist/cli.js

@@ -9,8 +9,9 @@ import { ALIAS_COMANDO, ALIAS_SI_NO, COMANDOS, t, USO } from "./textos.js";
 import { c, colorDeModo, fijarCapacidades, sep, signo, SIMBOLOS } from "./marca.js";
 import { guardarAjustes, leerAjustes, migrarCarpetaVieja, VERSION } from "./config.js";
 import { MODELO_POR_DEFECTO, MODELOS, modeloDe, nombreDeModelo } from "./modelos.js";
-import { correoVisible, crearMision, ErrorDeParallel, leerBandeja, leerCuenta, quienEs, responderBandeja, verMision } from "./api.js";
-import { comoHasEntrado, credencialesActivas, entrar, formaDeLaOpcion, salir } from "./cuenta.js";
+import { cicloDeMision, compartirMision, correoVisible, crearMision, ErrorDeParallel, leerBandeja, leerConexiones, leerCuenta, leerMisionDeLaCuenta, leerMisiones, leerPlantillas, quienEs, responderBandeja, verMision, } from "./api.js";
+import { abrirNavegador, comoHasEntrado, credencialesActivas, entrar, formaDeLaOpcion, salir } from "./cuenta.js";
+import { accionesDeUnaMision, filtrarPorTitulo, hace } from "./comandos.js";
 import { hacerTarea, mensajeDeError, nuevaSesion } from "./agente.js";
 import { deshacerUltimo, permitirCarpeta } from "./herramientas.js";
 import { Registro } from "./registro.js";
@@ -43,6 +44,8 @@ function opciones() {
             ascii: { type: 'boolean' },
             mouse: { type: 'boolean' },
             'no-mouse': { type: 'boolean' },
+            'no-animation': { type: 'boolean' },
+            animation: { type: 'boolean' },
             version: { type: 'boolean', short: 'v' },
             help: { type: 'boolean', short: 'h' },
             browser: { type: 'boolean' },
@@ -90,7 +93,7 @@ export function modosEnColor() {
     return `${nombres.slice(0, 3).join(', ')} or ${nombres[3]}`;
 }
 function ayudaDeComandos() {
-    return bloqueDeTabla([['!', t('tip.bash')], ...COMANDOS.map(([k, d]) => [`/${k}`, k === 'mode' ? modosEnColor() : d])], { pie: `${t('tui.atajos')}\n${t('tui.atajos_raton')}` });
+    return bloqueDeTabla([['!', t('tip.bash')], ...COMANDOS.map(([k, d]) => [`/${k}`, k === 'mode' ? modosEnColor() : d])], { pie: `${t('tui.atajos')}\n${t('tui.atajos_arroba')}\n${t('tui.atajos_raton')}` });
 }
 async function cuentaOError(cred, pantalla) {
     try {
@@ -262,10 +265,40 @@ async function principal() {
     const quien = quienEs(cuenta);
     let avisos = ajustes.avisos !== false;
     const conRaton = !v['no-mouse'] && v.mouse !== false && (Boolean(v.mouse) || ajustes.raton !== false);
+    pantalla.animar = !v['no-animation'] && v.animation !== false && (Boolean(v.animation) || ajustes.animacion !== false);
     let esperandoEnBandeja = null;
     let control = new AbortController();
     let ocupado = false;
     let superficie = null;
+    let bienvenida;
+    let consejosDeEntrada = [];
+    const confirmarNuevaEnMarcha = async () => {
+        if (!superficie)
+            return;
+        const i = await superficie.elegir(t('nueva.parar'), [{ etiqueta: t('nueva.si'), peligro: true }, { etiqueta: t('nueva.no') }], { detalle: t('nueva.parar_detalle'), elegida: 1 });
+        if (i !== 0)
+            return;
+        superficie.nuevaTrasParar();
+        if (ocupado)
+            control.abort();
+    };
+    const empezarDeNuevo = () => {
+        sesion.conversacion = [];
+        sesion.diario = [];
+        sesion.id = randomUUID();
+        sesion.ultimaTarea = undefined;
+        sesion.ctx.hechos = { ficheros: [], comandos: [] };
+        sesion.ctx.permitidos.clear();
+        sesion.ctx.deshacer.length = 0;
+        if (sesion.ctx.lecturas)
+            sesion.ctx.lecturas.length = 0;
+        registro.apuntar('nueva', {});
+        pantalla.reiniciar();
+        if (superficie)
+            superficie.reiniciar(bienvenida, consejosDeEntrada);
+        else
+            pantalla.escribir(t('repl.nueva'));
+    };
     let ctrlC = 0;
     const totalDeLaSesion = () => sesion.total.tareas ? c.gris(t('estado.total', { acciones: acciones(sesion.total.acciones), tiempo: duracion(sesion.total.ms) })) : '';
     const despedida = () => [totalDeLaSesion(), c.gris(t('repl.adios'))].filter(Boolean).join('\n  ');
@@ -401,6 +434,25 @@ async function principal() {
         extra: sesion.ensenar ? 'Teach' : undefined,
         esperando: esperandoEnBandeja ?? 0,
     });
+    let conexionesAl = 0;
+    let conexionesViejas = true;
+    let sinConexiones = false;
+    const cargarConexiones = async () => {
+        if (sinConexiones)
+            return;
+        conexionesAl = Date.now();
+        conexionesViejas = false;
+        try {
+            const r = await leerConexiones(cred.servidor, cred.token);
+            superficie?.fijarConexiones(r.conexiones);
+        }
+        catch (e) {
+            if (e instanceof ErrorDeParallel && (e.codigo === 'sin_acceso' || e.codigo === 'sesion'))
+                sinConexiones = true;
+            else
+                conexionesViejas = true;
+        }
+    };
     if (interactiva) {
         superficie = new Superficie({
             entrada: process.stdin,
@@ -419,6 +471,18 @@ async function principal() {
                 if (avisos && superficie?.enfocada === false)
                     avisarEnElEscritorio({ titulo: 'parx', texto: t('aviso.te_necesita', { pregunta: texto }) });
             },
+            alNuevaEnMarcha: () => void confirmarNuevaEnMarcha(),
+            alArroba: () => {
+                if (conexionesViejas || Date.now() - conexionesAl > 60_000)
+                    void cargarConexiones();
+            },
+            alConectar: (x) => {
+                abrirNavegador(x.url);
+                registro.apuntar('conectar', { provider: x.provider });
+                pantalla.escribir(t('arroba.abriendo', { nombre: x.nombre, url: c.marca(x.url) }));
+                pantalla.escribir(c.gris(t('arroba.despues')));
+                conexionesViejas = true;
+            },
         });
         const s = superficie;
         process.on('exit', () => s.restaurarDeUrgencia());
@@ -437,7 +501,8 @@ async function principal() {
         const elegidos = elegirConsejos(leerAjustes().consejos);
         if (elegidos.ids.length)
             guardarAjustes({ consejos: elegidos.estado });
-        superficie.iniciar(bloqueDeBienvenida({
+        consejosDeEntrada = conCarriles || quiereBypass ? [] : elegidos.ids;
+        bienvenida = bloqueDeBienvenida({
             version: VERSION,
             quien: quien.includes('@') ? quien : (quien.split(/\s+/)[0] ?? ''),
             carpeta: rutaCorta(raiz, 60),
@@ -447,7 +512,8 @@ async function principal() {
                 return nueva ? t('update.disponible', { version: nueva }) : undefined;
             })(),
             peligro: () => sesion.ctx.modo === 'bypass',
-        }), conCarriles || quiereBypass ? [] : elegidos.ids);
+        });
+        superficie.iniciar(bienvenida, consejosDeEntrada);
         if (quiereBypass)
             await confirmarBypass();
         const mirarBandeja = async () => {
@@ -469,6 +535,7 @@ async function principal() {
         const relojBandeja = setInterval(() => void mirarBandeja(), 90_000);
         relojBandeja.unref();
         void mirarBandeja();
+        void cargarConexiones();
     }
     const leerLinea = async (ejemplo = null) => {
         if (superficie)
@@ -605,6 +672,147 @@ async function principal() {
             elegida = Math.min(elegida, lista.length - 1);
         }
     };
+    const pedir = async (texto, fn, errores = {}) => {
+        ocupado = true;
+        control = new AbortController();
+        superficie?.trabajar(() => control.abort());
+        pantalla.espera(texto, 'ruta', true);
+        try {
+            return await fn(control.signal);
+        }
+        catch (e) {
+            if (!(e instanceof ErrorDeParallel))
+                throw e;
+            const clave = errores[e.codigo === 'servidor' ? e.detalle.slice(0, 3) : e.codigo];
+            if (clave)
+                pantalla.aviso(t(clave));
+            else if (e.codigo !== 'interrumpido')
+                pantalla.error(mensajeDeError(e));
+            return null;
+        }
+        finally {
+            pantalla.pararEspera();
+            ocupado = false;
+            superficie?.descansar();
+        }
+    };
+    const notaDeMision = (m) => [t('misiones.progreso', { estado: m.texto || m.estado, n: m.progreso }), m.pendientes ? t('misiones.esperan', { n: m.pendientes }) : ''].filter(Boolean).join(sep());
+    const erroresDeMision = { sin_acceso: 'misiones.no_existe', '409': 'misiones.no_se_puede', '429': 'misiones.despacio' };
+    const unaMision = async (inicial) => {
+        let m = inicial;
+        let elegida = 0;
+        for (;;) {
+            const acciones = accionesDeUnaMision(m.estado);
+            const j = await superficie.elegir(m.titulo, [...acciones.map((a) => ({ etiqueta: a.etiqueta, nota: a.nota })), { etiqueta: t('misiones.volver') }], {
+                vertical: true,
+                detalle: notaDeMision(m),
+                elegida,
+            });
+            if (j === null)
+                return 'salir';
+            if (j >= acciones.length)
+                return 'volver';
+            elegida = j;
+            const a = acciones[j];
+            registro.apuntar('mision_accion', { accion: a.slug });
+            if (a.id === 'abrir') {
+                abrirNavegador(m.url);
+                pantalla.escribir(t('misiones.abierta', { url: c.marca(m.url) }));
+            }
+            else if (a.id === 'pausar' || a.id === 'reanudar') {
+                const accion = a.id;
+                const r = await pedir(t('misiones.mirando'), (s) => cicloDeMision(cred.servidor, cred.token, m.id, accion, s), erroresDeMision);
+                if (r) {
+                    pantalla.escribir(`${c.ok(SIMBOLOS.hecho)} ${t(accion === 'pausar' ? 'misiones.pausada' : 'misiones.reanudada', { titulo: m.titulo })}`);
+                    const otra = await leerMisiones(cred.servidor, cred.token).catch(() => null);
+                    m = otra?.misiones.find((x) => x.id === m.id) ?? { ...m, estado: r.estado };
+                    elegida = 0;
+                }
+            }
+            else if (a.id === 'compartir') {
+                const r = await pedir(t('misiones.mirando'), (s) => compartirMision(cred.servidor, cred.token, m.id, s), { ...erroresDeMision, '503': 'misiones.sin_compartir' });
+                if (r)
+                    pantalla.escribir(t(copiarAlPortapapeles(r.url) ? 'misiones.compartida' : 'misiones.compartida_sin_copiar', { url: c.marca(r.url) }));
+            }
+            else {
+                const r = await pedir(t('misiones.mirando'), (s) => leerMisionDeLaCuenta(cred.servidor, cred.token, m.id, s), erroresDeMision);
+                if (!r)
+                    continue;
+                const d = r.mision;
+                const titulo = `${a.id === 'resultado' ? t('misiones.resultado') : t('misiones.actividad')}${sep()}${d.titulo}`;
+                if (a.id === 'resultado') {
+                    const filas = [
+                        [t('misiones.meta'), d.objetivo ? t('misiones.objetivo', { etiqueta: d.objetivo.etiqueta, valor: d.objetivo.valor.toLocaleString('en-US'), meta: d.objetivo.meta.toLocaleString('en-US') }) : t('misiones.sin_objetivo')],
+                        [t('misiones.el_plan'), t('misiones.plan', { estado: d.texto || d.estado, n: d.progreso })],
+                    ];
+                    pantalla.bloque(bloqueDeTabla(filas, { titulo, pie: t('misiones.ver_resultados', { url: d.resultados }), sangria: 2 }));
+                }
+                else {
+                    pantalla.bloque(bloqueDeTabla(d.actividad.map((x) => [hace(x.cuando), x.texto]), { titulo, pie: d.actividad.length ? t('misiones.ver_actividad', { url: d.url }) : t('misiones.sin_actividad'), sangria: 2 }));
+                }
+            }
+        }
+    };
+    const misiones = async (filtro) => {
+        const leer = () => pedir(t('misiones.mirando'), (s) => leerMisiones(cred.servidor, cred.token, s), { sin_acceso: 'misiones.no_disponible', '429': 'misiones.despacio' });
+        let r = await leer();
+        if (!r)
+            return;
+        if (!r.misiones.length) {
+            pantalla.escribir(t('misiones.nada'));
+            return;
+        }
+        let lista = filtrarPorTitulo(r.misiones, filtro);
+        if (!lista.length) {
+            pantalla.escribir(t('misiones.sin_coincidencias', { q: filtro }));
+            return;
+        }
+        if (!superficie) {
+            for (const m of lista)
+                pantalla.escribir(`${m.titulo}${c.gris(`${sep()}${notaDeMision(m)}`)}  ${c.gris(m.url)}`);
+            return;
+        }
+        let elegida = 0;
+        for (;;) {
+            const i = await superficie.elegir(t('misiones.titulo'), lista.map((m) => ({ etiqueta: m.titulo, nota: notaDeMision(m) })), { vertical: true, elegida });
+            if (i === null)
+                return;
+            elegida = i;
+            if ((await unaMision(lista[i])) === 'salir')
+                return;
+            r = await leer();
+            if (!r)
+                return;
+            lista = filtrarPorTitulo(r.misiones, filtro);
+            if (!lista.length)
+                return;
+            elegida = Math.min(elegida, lista.length - 1);
+        }
+    };
+    const plantillas = async (filtro) => {
+        const r = await pedir(t('plantillas.mirando'), (s) => leerPlantillas(cred.servidor, cred.token, s), { sin_acceso: 'misiones.no_disponible', '429': 'misiones.despacio' });
+        if (!r)
+            return;
+        if (!r.plantillas.length) {
+            pantalla.escribir(t('plantillas.nada'));
+            return;
+        }
+        const lista = filtrarPorTitulo(r.plantillas, filtro);
+        if (!lista.length) {
+            pantalla.escribir(t('plantillas.sin_coincidencias', { q: filtro }));
+            return;
+        }
+        if (!superficie) {
+            for (const p of lista)
+                pantalla.escribir(`${p.titulo}${p.resumen ? c.gris(`${sep()}${p.resumen}`) : ''}`);
+            return;
+        }
+        const i = await superficie.elegir(t('plantillas.titulo'), lista.map((p) => ({ etiqueta: p.titulo, nota: p.propia ? t('plantillas.propia') : p.resumen })), { vertical: true });
+        if (i === null)
+            return;
+        superficie.ponerEnLaCaja(`/mission ${lista[i].objetivo.replace(/\s+/g, ' ').trim()}`);
+        pantalla.escribir(c.gris(t('plantillas.lista')));
+    };
     const bash = async (comando) => {
         if (!comando)
             return;
@@ -811,6 +1019,23 @@ async function principal() {
                     await bandeja();
                     superficie?.pintar();
                     break;
+                case 'missions':
+                    await misiones(resto);
+                    superficie?.pintar();
+                    break;
+                case 'templates':
+                    await plantillas(resto);
+                    superficie?.pintar();
+                    break;
+                case 'connections':
+                case 'settings': {
+                    const url = `${cred.servidor.replace(/\/$/, '')}/${cmd}`;
+                    abrirNavegador(url);
+                    if (cmd === 'connections')
+                        conexionesViejas = true;
+                    pantalla.escribir(t('ir.abriendo', { que: t(cmd === 'connections' ? 'ir.conexiones' : 'ir.ajustes'), url: c.marca(url) }));
+                    break;
+                }
                 case 'mouse': {
                     const si = ALIAS_SI_NO[arg] ?? (superficie?.conRaton ? 'no' : 'si');
                     guardarAjustes({ raton: si === 'si' });
@@ -819,9 +1044,15 @@ async function principal() {
                     break;
                 }
                 case 'new':
-                    sesion.conversacion = [];
-                    pantalla.escribir(t('repl.nueva'));
+                    empezarDeNuevo();
                     break;
+                case 'animation': {
+                    const si = ALIAS_SI_NO[arg] ?? (pantalla.animar ? 'no' : 'si');
+                    pantalla.animar = si === 'si';
+                    guardarAjustes({ animacion: pantalla.animar });
+                    pantalla.escribir(pantalla.animar ? t('animacion.on') : t('animacion.off'));
+                    break;
+                }
                 case 'undo': {
                     const r2 = deshacerUltimo(sesion.ctx);
                     pantalla.escribir(r2 ? t('repl.deshecho', { ruta: r2 }) : t('repl.nada_que_deshacer'));