@getparallel/parx 0.5.0 → 0.7.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.7.0 (2026-10-18)
+
+- Un paso corto ya no tumba el plan; «Llévalo a tu negocio» lleva a la misión en marcha y sin palabras que disparen la plantilla de clientes
+- Del código al negocio (x03): «Llévalo a tu negocio» en Sesiones y /mission con el enlace de la web
+- Ver en el móvil la web que construye (x01)
+- El Mac siempre listo (x07): parx service on/off/add/remove/status, tareas abiertas desde el móvil
+
+## 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.

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).

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) {
@@ -117,3 +119,18 @@ 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 subirVistaRemota(servidor, token, id, cuerpo) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}/vista`, { token, cuerpo, plazoMs: 60_000 });
+}
+export function cerrarRemoto(servidor, token, id, plazoMs = 3000) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}`, { token, metodo: 'DELETE', plazoMs });
+}