@getparallel/parx 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -6,6 +6,31 @@ 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.4.2 (2026-10-11)
+
+- Bash mode: type `!` first and the input turns amber with a `bash` label; Enter runs the command in the project folder, its output streams into the conversation with the exit code, and the agent sees it next turn. Read only refuses, «Careful» commands ask first, credentials stay out of the conversation, Esc or Ctrl+C stops it.
+- Everything is clickable: permission questions, Accept/Decline, the `/` menu and its values, `/inbox` and the status row are buttons («[ 1 Yes ]  [ 2 Always ]  [ 3 No ]») with hover; the keyboard works as before. `/mouse on|off` and `--no-mouse`; Shift+drag selects text. The terminal always gets the mouse back (exit, Ctrl+Z, kill, crash).
+- The wheel and PgUp/PgDn scroll the conversation; «↓ Jump to bottom · N new» (or End) takes you back down. New output waits below while you read.
+- `/inbox` and «● 2 waiting»: answer what your Parallel missions are waiting for (approvals, proposed changes, your steps) from parx. Needs the matching getparallel.net release.
+- More air: a blank row between the conversation and the input and between the input and the status row, a blank row between groups (your message, actions, warnings, answers), the question as its own block, never two blank rows in a row. «Careful: leaves the project folder.» instead of the long sentence.
+- Ctrl+Z suspends parx like any terminal program; `fg` brings it back.
+- A question no longer hides the last lines above it: the warning it explains («never to the log.») stays on screen, and the answer is written whole at any width.
+- Credentials: when you ask for something that needs one, parx asks you (it no longer refuses on its own), and a «No» only counts for that task.
+- `/teach` explains every step and ends with a short lesson, also with Swift; `/teach <task>` turns it on and does the task.
+- Typing a whole command and Enter runs it (`/teach`, `/notify`, `/tips`, `/folder`) instead of waiting for a value.
+- `/help` and `/tips` wrap in two clean columns at any width, from 40 columns up.
+- Clearer notes: «3 lines», «2 items», «no matches», «… 8 more lines above»; test output shows pass and fail instead of the runner's filler.
+- `/mission` gives the link to the mission itself once it launches.
+- `/report` copies plain text (no backticks or asterisks) that reads well in an email or WhatsApp.
+- «Running tests» and «Building» only for real test and build commands, not for files like `sum.test.js`.
+- With `--lanes` in a narrow window, each lane keeps its task name instead of a lone «…».
+- Everything you type while parx works (or several lines at once) waits in line, in order; before, only the last one was kept.
+- A permission question that pops up while you are typing your next task is not answered by your Enter: what you typed stays in the box. Esc still answers «No» at once.
+
+## 0.4.1 (2026-10-10)
+
+- El nombre visible es siempre «parx», nunca «Par» (consejos, avisos, README)
+
 ## 0.4.0 (2026-10-10)
 
 - Published on npm as `@getparallel/parx` (install with `npm install -g @getparallel/parx`). The command is still `parx`.

package/README.md

@@ -78,8 +78,8 @@ when it asks first:
 | **Bypass** | no questions anywhere | no questions |
 
 - **Bypass** is never the default and never saved: turn it on yourself with `--bypass`, or with
-  `/mode bypass`, a clear warning and typing `bypass` to confirm. The status line shows `▲ Bypass` in
-  amber while it is on. Shift+Tab (Ask → Auto → Read only) leaves it.
+  `/mode bypass` and a clear warning to accept (Decline comes selected; you pick Accept). The status
+  line shows `▲ Bypass` in red while it is on. Shift+Tab (Ask → Auto → Read only) leaves it.
 - **Credentials always ask**, in every mode including Bypass: `.env` files, SSH keys, `~/.aws`,
   `.npmrc`, keychains, tokens. Each time it needs an explicit «Yes, this once» (No comes selected).
   Their paths, commands and contents never go to the log, and commands run with secret-looking
@@ -107,17 +107,35 @@ Type `/` for the commands; the menu filters as you type, ↑ ↓ move, Tab or En
 | `/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 |
+| `/inbox` | what your missions are waiting for (approvals, proposed changes, your steps), as buttons; what you pick takes effect like on the web |
 | `/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 |
 | `/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) |
+
+**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
+exit code. The agent sees the command and its output in the next task. Backspace on a lone `!`
+leaves the mode; Esc or Ctrl+C stops a running command. Read only runs nothing; a command with
+effects outside the project («Careful: leaves the project folder.») asks first (not in Bypass); the
+output of a command that touches credentials stays on your screen and out of the conversation.
+
+**Mouse:** click any option, button or menu item (permission questions, Accept/Decline, `/` menu,
+`/inbox`); hovering highlights but never picks. The wheel or PgUp/PgDn scroll the conversation; when
+you are up, a «↓ Jump to bottom» button (with «N new» if output arrived) takes you back, and so does
+End. To select text, drag with Shift (Option in iTerm2, Fn in macOS Terminal), or `/mouse off`. The
+terminal is always given back as it was: on exit, on Ctrl+Z, if parx is killed or crashes.
+
+**Waiting for you:** the status row shows «● 2 waiting» when your Parallel missions need an answer;
+click it or type `/inbox`. parx never approves anything on its own: always your click or your key.
 
 **Images:** drag a screenshot into the window (or paste its path) and it becomes a chip
 (`[Image · error.png]`); parx sends it with the task to understand the error or the design. PNG,
 JPEG, GIF or WebP; big ones are shrunk on macOS.
 
-**Par notifies you:** if you switch to another window while parx works, a desktop notification (macOS,
+**parx notifies you:** if you switch to another window while parx works, a desktop notification (macOS,
 Windows, Linux) with the Parallel sound tells you when it finishes or needs you. Terminals that do
 not report focus get it only for tasks longer than 45 s. `/notify off` turns it off.
 

package/dist/agente.js

@@ -29,15 +29,17 @@ const PERMISOS = {
     read: 'Read only: you can read and search, but you cannot write files or run commands. Explain what you would change instead.',
     bypass: 'Bypass: the user turned off the questions for this session; you can work anywhere on this computer. Be careful and do only what the task needs.',
 };
+export const RECORDATORIO_DE_CLASE = '(Teach mode is on: before each step, explain in 1-3 plain sentences what you will do and why; at the end, add a short lesson for a beginner.)';
 export function instrucciones(raiz, modo, o = {}) {
     const carpetas = o.carpetas?.length ? `\n- Allowed folders besides the project: ${o.carpetas.join(', ')}` : '';
     const clase = o.ensenar
         ? `
 
 # Teach mode (the user turned it on)
-- Work like a patient teacher. Before each step, say in 1-3 plain sentences what you are about to do and why.
+- Work like a patient teacher. Before EVERY tool call, write 1-3 plain sentences (as text, in the same reply) saying what you are about to do and why. Never call a tool without that explanation first.
 - After each change, explain the idea behind it (the concept, not just the code), as if to a beginner. Define any technical word the first time you use it.
-- Keep each explanation short and concrete; use the project's own code as the example.`
+- Keep each explanation short and concrete; use the project's own code as the example.
+- End with a short lesson (3-6 sentences) after the summary: the concept behind what you changed, for a beginner, with one tip to remember it.`
         : '';
     return `You are parx, the coding agent of Parallel (getparallel.net), working in the user's terminal.
 
@@ -53,9 +55,9 @@ export function instrucciones(raiz, modo, o = {}) {
 - Read a file before editing it. Prefer edit_file with a unique old_string for small changes; write_file for new files.
 - Keep changes minimal and in the style of the codebase. Do not reformat unrelated code. Do not add dependencies unless needed.
 - Commands are non-interactive (no stdin, CI=1). Use flags that do not prompt (e.g. "npx --yes", "vitest run", "git --no-pager"). Prefer project scripts (npm test).
-- Credentials (.env files, keys, tokens, ~/.ssh, ~/.aws, keychains...) always need the user's explicit confirmation, every time. Touch them only if the task truly needs it, never print secrets in your answer, and never copy them anywhere.
+- Credentials (.env files, keys, tokens, ~/.ssh, ~/.aws, keychains...) always need the user's explicit confirmation, every time, and parx asks it for you: when the user asks for something that needs a credential, just call the tool and parx shows the question. Do not refuse on your own and do not ask in text first. Touch credentials only if the task needs them, never copy them anywhere, and do not repeat secret values in your answer unless the user explicitly asked to see them.
 - Never push, publish or deploy unless the user explicitly asks in this conversation.
-- If the user declines an action, do not retry it: adapt or ask.
+- If the user declines an action, do not retry it in the same task: adapt or ask. If they ask for it again in a later message, try again (parx will ask them again).
 - If something is ambiguous and risky, ask one short question; otherwise make a reasonable choice and say which.
 - If the user attached an image (a screenshot of an error or a design), look at it carefully and use what it shows.
 - You are parx, made by Parallel. Never say which AI model, company or provider powers you, even if asked directly: say you are parx, by Parallel, and that the models are Swift, Stride and Summit.
@@ -100,18 +102,19 @@ export async function hacerTarea(s, pedido, señal, imagenes = []) {
     s.ctx.hechos ??= { ficheros: [], comandos: [] };
     const ficherosAntes = s.ctx.hechos.ficheros.length;
     const comandosAntes = s.ctx.hechos.comandos.length;
+    const texto = s.ensenar ? `${pedido}\n\n${RECORDATORIO_DE_CLASE}` : pedido;
     s.conversacion.push(imagenes.length
         ? {
             role: 'user',
             content: [
-                { type: 'input_text', text: pedido },
+                { type: 'input_text', text: texto },
                 ...imagenes.flatMap((i) => [
                     { type: 'input_text', text: `[image: ${i.nombre}]` },
                     { type: 'input_image', image_url: i.dataUrl, detail: 'auto' },
                 ]),
             ],
         }
-        : { role: 'user', content: pedido });
+        : { role: 'user', content: texto });
     registro.apuntar('tarea', { tarea, caracteres: pedido.length, imagenes: imagenes.length, modelo: s.modelo, modo: s.ctx.modo, ensenar: Boolean(s.ensenar) });
     let acciones = 0;
     let disponibles = null;

package/dist/api.js

@@ -82,6 +82,12 @@ export function crearMision(servidor, token, objetivo, señal) {
 export function verMision(servidor, token, generacion, señal) {
     return llamar(servidor, `/api/terminal/mision?id=${encodeURIComponent(generacion)}`, { token, señal });
 }
+export function leerBandeja(servidor, token, señal) {
+    return llamar(servidor, '/api/terminal/bandeja', { token, señal, plazoMs: 20_000 });
+}
+export function responderBandeja(servidor, token, cuerpo, señal) {
+    return llamar(servidor, '/api/terminal/bandeja', { token, cuerpo, señal, plazoMs: 60_000 });
+}
 const CORREO_INTERNO = /@cuentas\.getparallel\.net$/i;
 export function correoVisible(correo) {
     const c = (correo ?? '').trim();

package/dist/bash.js

@@ -0,0 +1,89 @@
+import { nivelDeComando } from "./seguridad.js";
+import { ejecutarComando, recortar } from "./shell.js";
+import { sinColor } from "./texto.js";
+import { t } from "./textos.js";
+import { bloqueDeFinDeBash, bloqueDeSalidaDeBash, duracion } from "./tui.js";
+export const MAX_LINEAS_A_LA_VISTA = 1000;
+export const PLAZO_BASH_MS = 600_000;
+export function lineasLimpias(texto) {
+    return sinColor(texto)
+        .split('\n')
+        .map((l) => {
+        const partes = l.replace(/\r+$/, '').split('\r');
+        return partes[partes.length - 1] ?? '';
+    });
+}
+export function textoParaElAgente(comando, r) {
+    if (!r.compartir)
+        return '(I ran a command in my own shell that touches credentials. Its output was kept out of this conversation on purpose.)';
+    const cabecera = r.plazoAgotado ? 'Timed out (killed).' : r.interrumpido ? 'Stopped by me before it finished.' : `Exit code: ${r.codigo}`;
+    return `(I ran this myself in my shell, in the project folder:\n$ ${comando}\n${cabecera}\n${recortar(r.salida.replace(/\r/g, ''), 12_000).trim() || '(no output)'})`;
+}
+export async function ejecutarBash(comando, ctx, señal, alEmpezar) {
+    const p = ctx.pantalla;
+    if (ctx.modo === 'read') {
+        p.aviso(t('bash.solo_lectura'));
+        ctx.registro.apuntar('bloqueado', { herramienta: 'bash', motivo: 'solo_lectura' });
+        return null;
+    }
+    const { nivel, motivo } = nivelDeComando(comando);
+    const credencial = nivel === 'credencial';
+    if (nivel === 'riesgo' && ctx.modo !== 'bypass') {
+        const r = await p.preguntar(t('pregunta.ejecutar'), { tipo: 'dos', aviso: t('aviso.riesgo', { motivo: motivo ?? '' }) });
+        if (r === 'no') {
+            ctx.registro.apuntar('rechazado', { herramienta: 'bash', comando: comando.slice(0, 500) });
+            return null;
+        }
+    }
+    alEmpezar?.();
+    p.marcarGrupo('accion');
+    let pendiente = '';
+    let vistas = 0;
+    let ocultas = 0;
+    const soltar = (todo) => {
+        const partes = pendiente.split('\n');
+        pendiente = todo ? '' : (partes.pop() ?? '');
+        const lineas = lineasLimpias(partes.join('\n'));
+        if (todo && lineas.length && lineas[lineas.length - 1] === '')
+            lineas.pop();
+        if (!partes.length || !lineas.length)
+            return;
+        const caben = Math.max(0, MAX_LINEAS_A_LA_VISTA - vistas);
+        const ahora = lineas.slice(0, caben);
+        ocultas += lineas.length - ahora.length;
+        vistas += ahora.length;
+        if (ahora.length)
+            p.bloque(bloqueDeSalidaDeBash(ahora), 'accion');
+    };
+    const reloj = setInterval(() => soltar(false), 80);
+    let res;
+    try {
+        res = await ejecutarComando(comando, {
+            cwd: ctx.raiz,
+            plazoMs: PLAZO_BASH_MS,
+            jaula: Boolean(ctx.jaula),
+            carpetas: ctx.carpetas ?? [],
+            señal,
+            alSalir: (trozo) => {
+                pendiente += trozo;
+            },
+        });
+    }
+    finally {
+        clearInterval(reloj);
+    }
+    soltar(true);
+    if (ocultas)
+        p.bloque(bloqueDeSalidaDeBash([t('bash.mas', { n: ocultas.toLocaleString('en-US') })]), 'accion');
+    const bien = res.codigo === 0 && !res.plazoAgotado && !res.interrumpido;
+    const tiempo = duracion(res.ms);
+    const fin = res.plazoAgotado ? `timeout · ${tiempo}` : res.interrumpido ? `${t('estado.interrumpido').replace(/\.$/, '')} · ${tiempo}` : `exit ${res.codigo ?? '?'} · ${tiempo}`;
+    p.bloque(bloqueDeFinDeBash(bien, vistas ? fin : `${t('bash.sin_salida')} · ${fin}`), 'accion');
+    if (credencial)
+        p.escribir(t('bash.no_compartido'), 'accion');
+    ctx.hechos ??= { ficheros: [], comandos: [] };
+    if (!credencial)
+        ctx.hechos.comandos.push({ comando: comando.slice(0, 200), codigo: res.codigo });
+    ctx.registro.apuntar('bash', { comando: credencial ? '[credential]' : comando.slice(0, 500), codigo: res.codigo, ms: res.ms, jaula: res.enJaula });
+    return { codigo: res.codigo, salida: res.salida, ms: res.ms, interrumpido: res.interrumpido, plazoAgotado: res.plazoAgotado, compartir: !credencial };
+}

package/dist/cli.js

@@ -6,24 +6,25 @@ import { basename, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { ALIAS_COMANDO, ALIAS_SI_NO, COMANDOS, t, USO } from "./textos.js";
-import { c, fijarCapacidades, sep, signo } from "./marca.js";
+import { c, 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, leerCuenta, quienEs, verMision } from "./api.js";
+import { correoVisible, crearMision, ErrorDeParallel, leerBandeja, leerCuenta, quienEs, responderBandeja, verMision } from "./api.js";
 import { comoHasEntrado, credencialesActivas, entrar, formaDeLaOpcion, salir } from "./cuenta.js";
 import { hacerTarea, mensajeDeError, nuevaSesion } from "./agente.js";
 import { deshacerUltimo, permitirCarpeta } from "./herramientas.js";
 import { Registro } from "./registro.js";
 import { Pantalla } from "./ui.js";
-import { acciones, bloqueDeBienvenida, bloqueDeLaPersona, duracion, Superficie } from "./tui.js";
+import { acciones, bloqueDeBienvenida, bloqueDeLaPersona, bloqueDeTabla, duracion, Superficie } from "./tui.js";
 import { CONSEJOS, cambiarConsejos, consejo, elegirConsejos, ordenDeConsejos } from "./consejos.js";
 import { anchoDe, recortarMedio } from "./texto.js";
 import { cargarImagen, ErrorDeImagen, extraerImagenes } from "./imagenes.js";
 import { avisarEnElEscritorio, debeAvisar } from "./notificar.js";
-import { copiarAlPortapapeles, escribirInforme } from "./informe.js";
+import { copiarAlPortapapeles, escribirInforme, textoParaPegar } from "./informe.js";
 import { objetivoDeMision } from "./mision.js";
 import { ejecutarCarriles, MAX_CARRILES } from "./carriles.js";
 import { spawnSync } from 'node:child_process';
+import { ejecutarBash, textoParaElAgente } from "./bash.js";
 import { comprobarDeFondo, esMasNueva, ordenDeActualizar, rutaDelCli, ultimaPublicada, versionNuevaConocida } from "./actualizar.js";
 function opciones() {
     return parseArgs({
@@ -40,6 +41,8 @@ function opciones() {
             lanes: { type: 'boolean' },
             dir: { type: 'string', short: 'C' },
             ascii: { type: 'boolean' },
+            mouse: { type: 'boolean' },
+            'no-mouse': { type: 'boolean' },
             version: { type: 'boolean', short: 'v' },
             help: { type: 'boolean', short: 'h' },
             browser: { type: 'boolean' },
@@ -83,9 +86,7 @@ export function modoDe(texto) {
 }
 export const SIGUIENTE_MODO = { ask: 'auto', auto: 'read', read: 'ask', bypass: 'ask' };
 function ayudaDeComandos() {
-    const ancho = Math.max(...COMANDOS.map(([k]) => anchoDe(k))) + 4;
-    const filas = COMANDOS.map(([k, d]) => `  ${c.marca(`/${k}`.padEnd(ancho))}${d}`);
-    return [...filas, '', c.gris(t('tui.atajos'))].join('\n');
+    return bloqueDeTabla([['!', t('tip.bash')], ...COMANDOS.map(([k, d]) => [`/${k}`, d])], { pie: `${t('tui.atajos')}\n${t('tui.atajos_raton')}` });
 }
 async function cuentaOError(cred, pantalla) {
     try {
@@ -256,6 +257,8 @@ async function principal() {
     const saldoCorto = () => (disponibles == null ? '' : disponibles.toLocaleString('en-US'));
     const quien = quienEs(cuenta);
     let avisos = ajustes.avisos !== false;
+    const conRaton = !v['no-mouse'] && v.mouse !== false && (Boolean(v.mouse) || ajustes.raton !== false);
+    let esperandoEnBandeja = null;
     let control = new AbortController();
     let ocupado = false;
     let superficie = null;
@@ -391,6 +394,7 @@ async function principal() {
         saldoCorto: saldoCorto(),
         peligro: sesion.ctx.modo === 'bypass',
         extra: sesion.ensenar ? 'Teach' : undefined,
+        esperando: esperandoEnBandeja ?? 0,
     });
     if (interactiva) {
         superficie = new Superficie({
@@ -404,6 +408,8 @@ async function principal() {
                     guardarAjustes({ modo: sesion.ctx.modo });
             },
             alSalir: adios,
+            raton: conRaton,
+            alBandeja: () => superficie?.escribirYMandar('/inbox'),
             alPreguntar: (texto) => {
                 if (avisos && superficie?.enfocada === false)
                     avisarEnElEscritorio({ titulo: 'parx', texto: t('aviso.te_necesita', { pregunta: texto }) });
@@ -411,6 +417,17 @@ async function principal() {
         });
         const s = superficie;
         process.on('exit', () => s.restaurarDeUrgencia());
+        for (const [señal, codigo] of [['SIGTERM', 143], ['SIGHUP', 129]]) {
+            process.on(señal, () => {
+                try {
+                    s.terminar();
+                }
+                catch {
+                    s.restaurarDeUrgencia();
+                }
+                process.exit(codigo);
+            });
+        }
         pantalla.fijarSuperficie(superficie);
         const elegidos = elegirConsejos(leerAjustes().consejos);
         if (elegidos.ids.length)
@@ -428,6 +445,25 @@ async function principal() {
         }), conCarriles || quiereBypass ? [] : elegidos.ids);
         if (quiereBypass)
             await confirmarBypass();
+        const mirarBandeja = async () => {
+            if (ocupado)
+                return;
+            try {
+                const r = await leerBandeja(cred.servidor, cred.token);
+                const n = r.elementos.length;
+                if (n !== esperandoEnBandeja) {
+                    esperandoEnBandeja = n;
+                    superficie?.pintar();
+                }
+            }
+            catch (e) {
+                if (e instanceof ErrorDeParallel && (e.codigo === 'sin_acceso' || e.codigo === 'sesion'))
+                    clearInterval(relojBandeja);
+            }
+        };
+        const relojBandeja = setInterval(() => void mirarBandeja(), 90_000);
+        relojBandeja.unref();
+        void mirarBandeja();
     }
     const leerLinea = async (ejemplo = null) => {
         if (superficie)
@@ -457,6 +493,131 @@ async function principal() {
         }
         return tareas;
     }
+    const pedirTexto = async (e, opcion) => {
+        const obligatorio = opcion === 'cambios' && e.texto_libre;
+        const opcional = e.tipo === 'paso' && opcion === 'hecho' && e.texto_libre;
+        if (!obligatorio && !opcional)
+            return undefined;
+        const l = ((await leerLinea(t(obligatorio ? 'bandeja.escribe' : 'bandeja.nota'))) ?? '').trim();
+        if (!l && obligatorio)
+            return null;
+        return l || undefined;
+    };
+    const bandeja = async () => {
+        const leer = async () => {
+            ocupado = true;
+            control = new AbortController();
+            superficie?.trabajar(() => control.abort());
+            pantalla.espera(t('bandeja.mirando'), 'ruta', true);
+            try {
+                const r = await leerBandeja(cred.servidor, cred.token, control.signal);
+                esperandoEnBandeja = r.elementos.length;
+                return r.elementos;
+            }
+            catch (e) {
+                if (!(e instanceof ErrorDeParallel))
+                    throw e;
+                if (e.codigo === 'sin_acceso')
+                    pantalla.error(t('bandeja.no_disponible'));
+                else if (e.codigo !== 'interrumpido')
+                    pantalla.error(mensajeDeError(e));
+                return null;
+            }
+            finally {
+                pantalla.pararEspera();
+                ocupado = false;
+                superficie?.descansar();
+            }
+        };
+        let lista = await leer();
+        if (!lista)
+            return;
+        if (!lista.length) {
+            pantalla.escribir(t('bandeja.nada'));
+            return;
+        }
+        if (!superficie) {
+            for (const e of lista)
+                pantalla.escribir(`${e.titulo}${c.gris(`${sep()}${e.mision}`)}  ${c.gris(e.url)}`);
+            return;
+        }
+        let elegida = 0;
+        for (;;) {
+            const i = await superficie.elegir(t('bandeja.titulo'), lista.map((e) => ({ etiqueta: e.titulo, nota: e.mision })), { vertical: true, elegida });
+            if (i === null)
+                break;
+            elegida = i;
+            const e = lista[i];
+            if (!e.opciones.length) {
+                pantalla.escribir(t('bandeja.abrir', { url: c.marca(e.url) }));
+                continue;
+            }
+            const recomendada = Math.max(0, e.opciones.findIndex((o) => o.recomendada));
+            const j = await superficie.elegir(e.titulo, [...e.opciones.map((o) => ({ etiqueta: o.etiqueta, recomendada: o.recomendada, peligro: o.peligro })), { etiqueta: t('bandeja.volver') }], { detalle: [e.mision, e.detalle].filter(Boolean).join(sep()), elegida: recomendada });
+            if (j === null || j >= e.opciones.length)
+                continue;
+            const opcion = e.opciones[j];
+            const texto = await pedirTexto(e, opcion.id);
+            if (texto === null) {
+                pantalla.escribir(c.gris(t('bandeja.cancelado')));
+                continue;
+            }
+            ocupado = true;
+            control = new AbortController();
+            superficie.trabajar(() => control.abort());
+            pantalla.espera(t('bandeja.mirando'), 'ruta', true);
+            try {
+                const r = await responderBandeja(cred.servidor, cred.token, { id: e.id, opcion: opcion.id, ...(texto ? { texto } : {}) }, control.signal);
+                registro.apuntar('bandeja', { tipo: e.tipo, opcion: opcion.id.replace(/:.*/, '') });
+                const hecho = { approved: 'bandeja.hecho_aprobado', rejected: 'bandeja.hecho_rechazado', revising: 'bandeja.hecho_cambios', done: 'bandeja.hecho_paso', skipped: 'bandeja.hecho_saltado' };
+                pantalla.escribir(`${c.ok(SIMBOLOS.hecho)} ${t(hecho[r.estado] ?? 'bandeja.hecho_aprobado')}${c.gris(`${sep()}${e.mision}`)}`);
+            }
+            catch (err) {
+                if (!(err instanceof ErrorDeParallel))
+                    throw err;
+                if (err.codigo === 'servidor' && err.detalle.startsWith('409'))
+                    pantalla.aviso(t('bandeja.ya'));
+                else if (err.codigo === 'sin_acceso')
+                    pantalla.aviso(t('bandeja.no_existe'));
+                else if (err.codigo === 'servidor' && err.detalle.startsWith('429'))
+                    pantalla.aviso(t('bandeja.despacio'));
+                else if (err.codigo !== 'interrumpido')
+                    pantalla.error(mensajeDeError(err));
+            }
+            finally {
+                pantalla.pararEspera();
+                ocupado = false;
+                superficie.descansar();
+            }
+            lista = await leer();
+            superficie.pintar();
+            if (!lista)
+                return;
+            if (!lista.length) {
+                pantalla.escribir(t('bandeja.todo'));
+                return;
+            }
+            elegida = Math.min(elegida, lista.length - 1);
+        }
+    };
+    const bash = async (comando) => {
+        if (!comando)
+            return;
+        control = new AbortController();
+        try {
+            const r = await ejecutarBash(comando, sesion.ctx, control.signal, () => {
+                ocupado = true;
+                superficie?.trabajar(() => control.abort());
+                superficie?.textoDeTrabajo(t('bash.corriendo', { comando: comando.length > 28 ? `${comando.slice(0, 27)}…` : comando }), 'tren', true);
+            });
+            if (r)
+                sesion.conversacion.push({ role: 'user', content: textoParaElAgente(comando, r) });
+        }
+        finally {
+            ocupado = false;
+            superficie?.descansar();
+        }
+    };
     for (;;) {
         const r = await leerLinea();
         if (r === null)
@@ -465,6 +626,10 @@ async function principal() {
         ctrlC = 0;
         if (!linea)
             continue;
+        if (linea.startsWith('!')) {
+            await bash(linea.slice(1).trim());
+            continue;
+        }
         if (linea.startsWith('/')) {
             const [nombre = '', ...args] = linea.slice(1).split(/\s+/);
             const cmd = ALIAS_COMANDO[nombre.toLowerCase()];
@@ -479,7 +644,7 @@ async function principal() {
                     rl?.close();
                     return 0;
                 case 'help':
-                    pantalla.escribir(ayudaDeComandos());
+                    pantalla.bloque(ayudaDeComandos());
                     break;
                 case 'mode': {
                     const m = modoDe(arg);
@@ -534,10 +699,18 @@ async function principal() {
                     break;
                 }
                 case 'teach': {
-                    const si = ALIAS_SI_NO[arg] ?? (sesion.ensenar ? 'no' : 'si');
+                    const tareaConClase = !ALIAS_SI_NO[arg] && resto ? resto : null;
+                    const si = tareaConClase ? 'si' : (ALIAS_SI_NO[arg] ?? (sesion.ensenar ? 'no' : 'si'));
+                    const cambia = sesion.ensenar !== (si === 'si');
                     sesion.ensenar = si === 'si';
-                    pantalla.escribir(sesion.ensenar ? t('repl.ensenar_on') : t('repl.ensenar_off'));
+                    if (cambia || !tareaConClase)
+                        pantalla.escribir(sesion.ensenar ? t('repl.ensenar_on') : t('repl.ensenar_off'));
                     superficie?.pintar();
+                    if (tareaConClase && !(await hacer(tareaConClase))) {
+                        superficie?.terminar(despedida());
+                        rl?.close();
+                        return 1;
+                    }
                     break;
                 }
                 case 'report': {
@@ -558,7 +731,7 @@ async function principal() {
                         pantalla.escribir();
                         pantalla.texto(`**${t('informe.titulo')}**\n\n${inf.texto}`);
                         pantalla.escribir();
-                        pantalla.cierre(`${copiarAlPortapapeles(inf.texto) ? t('informe.copiado') : t('informe.titulo')}${c.gris(sep())}${c.gris(acciones(inf.acciones))}`);
+                        pantalla.cierre(`${copiarAlPortapapeles(textoParaPegar(inf.texto)) ? t('informe.copiado') : t('informe.titulo')}${c.gris(sep())}${c.gris(acciones(inf.acciones))}`);
                     }
                     catch (e) {
                         pantalla.pararEspera();
@@ -602,8 +775,11 @@ async function principal() {
                                 break;
                             }
                         }
-                        if (vista.estado === 'launched')
+                        if (vista.estado === 'launched') {
                             pantalla.cierre(t('mision.lanzada'));
+                            if (vista.mision && vista.url && vista.url !== m.url)
+                                pantalla.escribir(t('mision.aqui', { url: c.marca(vista.url) }));
+                        }
                         else if (vista.estado === 'failed')
                             pantalla.error(t('mision.no_disponible'));
                     }
@@ -626,6 +802,17 @@ async function principal() {
                     }
                     break;
                 }
+                case 'inbox':
+                    await bandeja();
+                    superficie?.pintar();
+                    break;
+                case 'mouse': {
+                    const si = ALIAS_SI_NO[arg] ?? (superficie?.conRaton ? 'no' : 'si');
+                    guardarAjustes({ raton: si === 'si' });
+                    superficie?.fijarRaton(si === 'si');
+                    pantalla.escribir(si === 'si' ? t('raton.on') : t('raton.off'));
+                    break;
+                }
                 case 'new':
                     sesion.conversacion = [];
                     pantalla.escribir(t('repl.nueva'));
@@ -666,11 +853,9 @@ async function principal() {
                     }
                     else {
                         const todos = CONSEJOS.map((id) => consejo(id));
-                        const ancho = Math.max(...todos.map((k) => anchoDe(k.tecla))) + 3;
-                        const filas = todos.map((k) => `  ${c.marca(k.tecla + ' '.repeat(Math.max(0, ancho - anchoDe(k.tecla))))}${k.texto}`);
                         const apagados = leerAjustes().consejos?.apagados;
                         const pie = apagados ? t('consejos.apagados', { orden: ordenDeConsejos(true) }) : t('consejos.quitar', { orden: ordenDeConsejos(false) });
-                        pantalla.escribir([c.negrita(t('consejos.titulo')), ...filas, '', c.gris(pie)].join('\n'));
+                        pantalla.bloque(bloqueDeTabla(todos.map((k) => [k.tecla, k.texto]), { titulo: t('consejos.titulo'), pie, sangria: 2 }));
                     }
                     break;
                 }

package/dist/consejos.js

@@ -1,6 +1,6 @@
 import { capacidades } from "./marca.js";
 import { t } from "./textos.js";
-export const CONSEJOS = ['menu', 'modo', 'una', 'imagen', 'historial', 'pegar', 'deshacer', 'modelo', 'carriles', 'parar', 'cola', 'informe', 'mision', 'ensenar', 'saldo', 'cuenta', 'agents'];
+export const CONSEJOS = ['menu', 'modo', 'una', 'bash', 'imagen', 'historial', 'pegar', 'deshacer', 'modelo', 'carriles', 'parar', 'cola', 'bandeja', 'raton', 'informe', 'mision', 'ensenar', 'saldo', 'cuenta', 'agents'];
 export function consejo(id) {
     const u = capacidades().unicode;
     const tecla = {
@@ -21,6 +21,9 @@ export function consejo(id) {
         saldo: '/balance',
         cuenta: 'parx account',
         agents: 'AGENTS.md',
+        bash: '!',
+        bandeja: '/inbox',
+        raton: 'Click',
     };
     return { tecla: tecla[id], texto: t(`tip.${id}`) };
 }