@getparallel/parx 0.4.4 → 0.6.0

package/CHANGELOG.md

@@ -6,6 +6,22 @@ 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.6.0 (2026-10-18)
+
+- parx updates itself. Every few hours it checks npm in the background; a new version is downloaded, verified (npm's registry signature against npm's public key pinned in parx, plus the package's SHA-512) and start-tested, then kept ready in `~/.config/parx/versiones`. It starts with your next session, never mid-session, with one line: «parx 0.5.1 updated · what's new». If a new version fails to start, parx goes back to the previous one on its own. `/autoupdate off` (or `PARX_NO_AUTO_UPDATE=1`) keeps the old behaviour: a line when there is a new version, and `parx update` installs it.
+- `parx update` now installs with the same verification, right away, and tells you the version is ready for your next session. Through `npx` or from a development copy, it just says so.
+- `/undo` survives `/new`: the files you changed are still on disk when the conversation is gone, so the last change can still be undone.
+- Before each task, one grey line says what it will roughly cost, «~150 Actions (estimate)», and, when a cheaper model would clearly do (a question, a small change), «with Swift: ~12». The estimate learns from your own tasks: after each one it compares estimate and real cost and corrects itself, per kind of task and model (`~/.config/parx/estimaciones.json`).
+- parx spends less: what the last turns are using stays whole, but older tool outputs are trimmed and files already written are replaced by a short note (they are on disk), so each turn re-sends far less; reasoning from earlier tasks is dropped; and the instructions ask for several tools per turn, no re-reading of files just written, one verification at the end and no fetching of external resources unless asked. A simple one-page site that cost 436 Actions with Stride now costs a fraction (measured below).
+
+## 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`.

package/README.md

@@ -33,11 +33,17 @@ You need a [Parallel](https://getparallel.net) account: each task is charged in
 
 ## Updates
 
-parx checks npm for a new version at most once a day, in the background and with a short timeout
-(it never slows anything down), and shows one discreet line when there is one,
-«parx 0.4.2 available · run `parx update`». `parx update` runs the right command for how you
-installed it (npm, pnpm, bun, yarn or Homebrew). Set `PARX_NO_UPDATE_CHECK=1` (or
-`NO_UPDATE_NOTIFIER=1`) to turn the check off; it is also off in CI.
+parx keeps itself up to date. Every few hours it checks npm in the background (short timeout, never
+slows anything down); when there is a new version it downloads it, verifies it is the one Parallel
+published (npm's registry signature, checked against npm's public key pinned in parx, plus the
+package's SHA-512) and that it starts, and keeps it ready in its own folder (`~/.config/parx/versiones`).
+Nothing changes mid-session: the new version starts with your next session, with one discreet line,
+«parx 0.5.1 updated · …». If a new version fails to start, parx goes back to the previous one by itself.
+
+`parx update` fetches the latest version right now, with the same checks. `/autoupdate off` (or
+`PARX_NO_AUTO_UPDATE=1`) makes parx only tell you, «parx 0.5.1 available · run `parx update`».
+`PARX_NO_UPDATE_CHECK=1` (or `NO_UPDATE_NOTIFIER=1`) turns the check off entirely; it is also off in
+CI, through `npx` (which already fetches the latest) and in a development copy of the repo.
 
 Every change ships as a new version ([semver](https://semver.org)); see the
 [changelog](https://www.npmjs.com/package/@getparallel/parx?activeTab=code) (`CHANGELOG.md` in the package).
@@ -112,11 +118,14 @@ Type `/` for the commands; the menu filters as you type, ↑ ↓ move, Tab or En
 | 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 |
 | `/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 |
@@ -126,6 +135,12 @@ Type `/` for the commands; the menu filters as you type, ↑ ↓ move, Tab or En
 | `/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
 exit code. The agent sees the command and its output in the next task. Backspace on a lone `!`

package/dist/actualizar.js

@@ -4,6 +4,7 @@ import { carpetaDeConfiguracion, VERSION } from "./config.js";
 export const PAQUETE = '@getparallel/parx';
 export const PAQUETE_EN_URL = PAQUETE.replace('/', '%2f');
 export const UN_DIA_MS = 24 * 60 * 60 * 1000;
+export const ENTRE_COMPROBACIONES_MS = 6 * 60 * 60 * 1000;
 const PLAZO_MS = 2500;
 const FICHERO = 'actualizacion.json';
 export function comprobacionApagada(env = process.env) {
@@ -72,7 +73,7 @@ export async function comprobarDeFondo(opts = {}) {
     const ahora = opts.ahora ?? Date.now();
     const e = leerEstado(dir);
     const hace = e ? ahora - Date.parse(e.comprobada) : Infinity;
-    if (e && hace >= 0 && hace < UN_DIA_MS)
+    if (e && hace >= 0 && hace < ENTRE_COMPROBACIONES_MS)
         return esMasNueva(e.ultima, opts.actual ?? VERSION) ? e.ultima : null;
     const ultima = await ultimaPublicada(opts);
     guardarEstado(dir, { comprobada: new Date(ahora).toISOString(), ultima: ultima ?? e?.ultima ?? opts.actual ?? VERSION });

package/dist/agente.js

@@ -8,8 +8,12 @@ import { c, sep as separador } from "./marca.js";
 import { descripcionDelSistema, esRepoGit } from "./shell.js";
 import { MODELOS } from "./modelos.js";
 import { acciones as textoDeAcciones, duracion } from "./tui.js";
+import { aprenderDeLaTarea, estimarTarea, leerCalibracion, lineaDeEstimacion } from "./estimacion.js";
 const MAX_VUELTAS = 80;
-const MAX_CARACTERES_DE_CONTEXTO = 900_000;
+const MAX_CARACTERES_DE_CONTEXTO = 400_000;
+const SALIDA_VIEJA_MAX = 1_500;
+const SALIDA_VIEJA_CABEZA = 500;
+const CONTENIDO_VIEJO_MAX = 600;
 function notasDelProyecto(raiz) {
     for (const nombre of ['PARALLEL.md', 'AGENTS.md']) {
         const ruta = join(raiz, nombre);
@@ -55,6 +59,7 @@ 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).
+- Spend little. Every turn re-sends the whole conversation, so fewer turns and shorter tool outputs cost the user less. Call several independent tools in ONE turn (list, search and read together; write several files together). Read only the files and line ranges you need; do not re-read a file you just wrote. For a small or simple task (a page, a script, a fix) skip exploring beyond one list_files and write the files directly. Verify once, at the end, with the project's own test or build command; if there is none (a static page, a script), one syntax check at most and then finish: do not invent checks with sed, grep or ad-hoc scripts, and do not re-read files to confirm what you just wrote. Do not fetch external resources (images, URLs, packages) unless the user asked for them.
 - 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 in the same task: adapt or ask. If they ask for it again in a later message, try again (parx will ask them again).
@@ -69,6 +74,63 @@ export function instrucciones(raiz, modo, o = {}) {
 export function nuevaSesion(servidor, token, modelo, ctx) {
     return { id: randomUUID(), servidor, token, modelo, ctx, conversacion: [], total: { acciones: 0, ms: 0, tareas: 0 }, diario: [] };
 }
+export function reiniciarConversacion(s) {
+    s.conversacion = [];
+    s.diario = [];
+    s.id = randomUUID();
+    s.ultimaTarea = undefined;
+    s.ctx.hechos = { ficheros: [], comandos: [] };
+    s.ctx.permitidos.clear();
+    if (s.ctx.lecturas)
+        s.ctx.lecturas.length = 0;
+}
+function notaDeContenido(texto) {
+    const lineas = texto.split('\n').length;
+    return `[${texto.length} characters, ${lineas} lines: written to disk as requested]`;
+}
+export function compactarConversacion(items, l) {
+    let ahorro = 0;
+    const desde = Math.max(0, l.desde);
+    const limite = Math.min(items.length, Math.max(desde, l.limite));
+    const limiteEscrituras = Math.min(items.length, Math.max(desde, l.limiteEscrituras ?? l.limite));
+    for (let i = items.length - 1; i >= 0; i--) {
+        const it = items[i];
+        const viejo = i < limite || i < desde;
+        const escrito = i < limiteEscrituras || i < desde;
+        if (!viejo && !escrito)
+            continue;
+        if (it.type === 'reasoning' && i < desde) {
+            ahorro += JSON.stringify(it).length;
+            items.splice(i, 1);
+            continue;
+        }
+        const salida = viejo && it.type === 'function_call_output' && typeof it.output === 'string' ? it.output : null;
+        if (salida !== null && salida.length > SALIDA_VIEJA_MAX) {
+            const nueva = `${salida.slice(0, SALIDA_VIEJA_CABEZA)}\n[… ${salida.length - SALIDA_VIEJA_CABEZA} more characters removed to save space; call the tool again if needed]`;
+            it.output = nueva;
+            ahorro += salida.length - nueva.length;
+            continue;
+        }
+        if (escrito && it.type === 'function_call' && (it.name === 'write_file' || it.name === 'edit_file') && typeof it.arguments === 'string' && it.arguments.length > CONTENIDO_VIEJO_MAX) {
+            try {
+                const args = JSON.parse(it.arguments);
+                const campo = it.name === 'write_file' ? 'content' : 'new_string';
+                const texto = args[campo];
+                if (typeof texto === 'string' && texto.length > CONTENIDO_VIEJO_MAX && !texto.startsWith('[')) {
+                    args[campo] = notaDeContenido(texto);
+                    if (it.name === 'edit_file' && typeof args.old_string === 'string' && args.old_string.length > CONTENIDO_VIEJO_MAX)
+                        args.old_string = `[${args.old_string.length} characters]`;
+                    const nuevo = JSON.stringify(args);
+                    ahorro += it.arguments.length - nuevo.length;
+                    it.arguments = nuevo;
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return ahorro;
+}
 function recortarContexto(items) {
     let total = JSON.stringify(items).length;
     for (let i = 0; i < items.length - 8 && total > MAX_CARACTERES_DE_CONTEXTO; i++) {
@@ -116,6 +178,17 @@ export async function hacerTarea(s, pedido, señal, imagenes = []) {
         }
         : { 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) });
+    const desde = s.conversacion.length - 1;
+    compactarConversacion(s.conversacion, { desde, limite: desde });
+    const vueltas = [];
+    let estimacion = null;
+    if (s.tarifas) {
+        s.calibracion ??= leerCalibracion();
+        const contextoChars = instrucciones(s.ctx.raiz, s.ctx.modo, { carpetas: s.ctx.carpetas, ensenar: s.ensenar }).length + JSON.stringify(DEFINICIONES).length + JSON.stringify(s.conversacion).length;
+        estimacion = estimarTarea({ pedido, contextoChars, tarifas: s.tarifas, calibracion: s.calibracion });
+        pantalla.escribir(c.gris(lineaDeEstimacion(estimacion, s.modelo)));
+        registro.apuntar('estimacion', { tarea, clase: estimacion.clase, estimada: estimacion.acciones[s.modelo] });
+    }
     let acciones = 0;
     let disponibles = null;
     let respuesta = '';
@@ -139,6 +212,9 @@ export async function hacerTarea(s, pedido, señal, imagenes = []) {
         for (let vuelta = 0; vuelta < MAX_VUELTAS; vuelta++) {
             if (señal.aborted)
                 throw new ErrorDeParallel('interrumpido');
+            vueltas.push(s.conversacion.length);
+            if (vuelta > 0)
+                compactarConversacion(s.conversacion, { desde, limite: vueltas[vueltas.length - 2] ?? desde });
             recortarContexto(s.conversacion);
             pantalla.espera(null);
             const r = await turno(s.servidor, s.token, {
@@ -206,7 +282,9 @@ export async function hacerTarea(s, pedido, señal, imagenes = []) {
     s.ultimaTarea = { acciones, ms };
     s.disponibles = disponibles;
     apuntarDiario();
-    registro.apuntar('tarea_hecha', { tarea, acciones, ms });
+    registro.apuntar('tarea_hecha', { tarea, acciones, ms, ...(estimacion ? { estimada: estimacion.acciones[s.modelo], clase: estimacion.clase } : {}) });
+    if (estimacion && acciones > 0)
+        s.calibracion = aprenderDeLaTarea({ clase: estimacion.clase, modelo: s.modelo, estimada: estimacion.acciones[s.modelo], real: acciones, calibracion: s.calibracion });
     const sep = c.gris(separador());
     pantalla.cierre(`${t('estado.hecho')}${sep}${c.gris(textoDeAcciones(acciones))}${sep}${c.gris(duracion(ms))}`);
     return true;
@@ -253,6 +331,8 @@ export function mensajeDeError(e) {
             return t('error.sin_acceso');
         case 'demasiado':
             return t('error.demasiado');
+        case 'ia':
+            return t('error.ia');
         case 'red':
             return t('error.red', { detalle: e.detalle });
         default:

package/dist/api.js

@@ -59,6 +59,8 @@ async function llamar(servidor, ruta, init = {}) {
         throw new ErrorDeParallel('servidor', 'mantenimiento');
     if (r.status === 413)
         throw new ErrorDeParallel('demasiado');
+    if ((r.status === 502 || r.status === 503 || r.status === 504) && (error === 'no_disponible' || error === 'servicio' || error === 'plazo' || error === ''))
+        throw new ErrorDeParallel('ia', `${r.status}${error ? ` ${error}` : ''}`);
     throw new ErrorDeParallel('servidor', `${r.status}${error ? ` ${error}` : ''}`);
 }
 export function pedirCodigo(servidor) {
@@ -88,6 +90,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();
@@ -99,3 +119,15 @@ export function quienEs(cu) {
         return nombre;
     return correoVisible(cu?.correo);
 }
+export function abrirRemoto(servidor, token, datos) {
+    return llamar(servidor, '/api/terminal/remoto', { token, cuerpo: datos, plazoMs: 20_000 });
+}
+export function latidoRemoto(servidor, token, id, cuerpo, señal) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}`, { token, cuerpo, señal, plazoMs: 20_000 });
+}
+export function ordenesRemotas(servidor, token, id, esperaMs, señal) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}/ordenes?espera=${esperaMs}`, { token, señal, plazoMs: esperaMs + 15_000 });
+}
+export function cerrarRemoto(servidor, token, id, plazoMs = 3000) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}`, { token, metodo: 'DELETE', plazoMs });
+}