@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/descubrimiento/skills.js

@@ -0,0 +1,113 @@
+/**
+ * Skills que otras herramientas dejaron en el proyecto: `.claude/skills/<nombre>/SKILL.md`
+ * y `.github/skills/`.
+ *
+ * No se reimplementa el parseo de SKILL.md: `../skills.ts` ya sabe leer
+ * frontmatter, validar nombre/descripción y bajar por subdirectorios — es
+ * exactamente el mismo formato (Agent Skills).
+ *
+ * `instalarSkillsDescubiertas` es la parte que las hace disponibles DE
+ * VERDAD, no solo listadas: enlaza cada una dentro de `.ada/skills`, la
+ * carpeta de proyecto que `core/skills.ts` YA recorre sin que se le haya
+ * tocado ni una línea. Es la alternativa a pasar `additionalSkillPaths` por
+ * `agent-session-services.ts` — que también habría funcionado, pero ese
+ * fichero es de upstream y el presupuesto de sincronización ya estaba en
+ * 115/115 antes de este cambio (`./scripts/sync-ada.sh --check`). Un symlink
+ * en un directorio que Ada ya escanea consigue lo mismo por CERO hunks.
+ */
+import { lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { CONFIG_DIR_NAME } from "../../config.js";
+import { loadSkillsFromDir } from "../skills.js";
+const FUENTES = [
+    { origen: "Claude Code", relativa: ".claude/skills" },
+    { origen: "GitHub Copilot", relativa: ".github/skills" },
+];
+export function descubrirSkills(cwd) {
+    const skills = [];
+    const directoriosMirados = [];
+    const errores = [];
+    for (const fuente of FUENTES) {
+        directoriosMirados.push(fuente.relativa);
+        const dir = join(cwd, fuente.relativa);
+        // Directorio ausente: "no hay", `loadSkillsFromDir` devuelve vacío sin
+        // diagnóstico. Un SKILL.md que existe pero no pasa el parseo SÍ genera uno:
+        // esa es la diferencia entre "no hay" y "no he podido" que pide la regla 6.
+        const { skills: encontradas, diagnostics } = loadSkillsFromDir({ dir, source: `descubierta:${fuente.origen}` });
+        for (const skill of encontradas) {
+            skills.push({
+                origen: fuente.origen,
+                ruta: skill.filePath,
+                baseDir: skill.baseDir,
+                nombre: skill.name,
+                descripcion: skill.description,
+            });
+        }
+        for (const diagnostic of diagnostics) {
+            errores.push({ ruta: diagnostic.path ?? dir, motivo: diagnostic.message });
+        }
+    }
+    return { skills, directoriosMirados, errores };
+}
+function slugificar(texto) {
+    return texto
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-+|-+$)/g, "");
+}
+/**
+ * Deja `enlace` como symlink a `destino`. Devuelve false sin tocar nada si
+ * `enlace` ya existe y NO es un symlink nuestro — nunca se borra un fichero
+ * real que el usuario pueda tener ahí con el mismo nombre.
+ */
+function asegurarEnlace(destino, enlace) {
+    try {
+        const info = lstatSync(enlace);
+        if (!info.isSymbolicLink())
+            return false;
+        if (resolve(dirname(enlace), readlinkSync(enlace)) === destino)
+            return true; // ya estaba
+        unlinkSync(enlace);
+    }
+    catch {
+        // no existe todavía: se crea abajo
+    }
+    try {
+        symlinkSync(destino, enlace, "dir");
+        return true;
+    }
+    catch {
+        // sistema de ficheros sin symlinks (o sin permiso): se queda sin instalar,
+        // pero sigue apareciendo en `descubrirSkills` — listada, no disponible.
+        return false;
+    }
+}
+/**
+ * Enlaza cada skill descubierta dentro de `.ada/skills` para que la próxima
+ * sesión (interactiva, `serve`, `acp`...) la cargue de verdad, sin que nadie
+ * tenga que pasar `--skill` a mano.
+ *
+ * ponytail: no limpia symlinks de skills que dejaron de existir en origen.
+ * Un symlink roto no rompe nada — `core/skills.ts` ya lo salta en silencio —
+ * pero se queda ahí. Si el descuido empieza a notarse, un `discover --prune`
+ * que borre los symlinks propios (prefijo `descubierta-`) que ya no resuelven
+ * es la subida natural.
+ */
+export function instalarSkillsDescubiertas(cwd) {
+    const { skills } = descubrirSkills(cwd);
+    if (skills.length === 0)
+        return [];
+    const destinoBase = join(cwd, CONFIG_DIR_NAME, "skills");
+    mkdirSync(destinoBase, { recursive: true });
+    const instaladas = [];
+    for (const skill of skills) {
+        const slug = `descubierta-${slugificar(skill.origen)}-${basename(skill.baseDir)}`;
+        const enlace = join(destinoBase, slug);
+        const destino = resolve(skill.baseDir);
+        if (asegurarEnlace(destino, enlace)) {
+            instaladas.push({ nombre: skill.nombre, origen: skill.origen, enlace });
+        }
+    }
+    return instaladas;
+}
+//# sourceMappingURL=skills.js.map

package/dist/core/descubrimiento/skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../../src/core/descubrimiento/skills.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Skills que otras herramientas dejaron en el proyecto: `.claude/skills/<nombre>/SKILL.md`\n * y `.github/skills/`.\n *\n * No se reimplementa el parseo de SKILL.md: `../skills.ts` ya sabe leer\n * frontmatter, validar nombre/descripción y bajar por subdirectorios — es\n * exactamente el mismo formato (Agent Skills).\n *\n * `instalarSkillsDescubiertas` es la parte que las hace disponibles DE\n * VERDAD, no solo listadas: enlaza cada una dentro de `.ada/skills`, la\n * carpeta de proyecto que `core/skills.ts` YA recorre sin que se le haya\n * tocado ni una línea. Es la alternativa a pasar `additionalSkillPaths` por\n * `agent-session-services.ts` — que también habría funcionado, pero ese\n * fichero es de upstream y el presupuesto de sincronización ya estaba en\n * 115/115 antes de este cambio (`./scripts/sync-ada.sh --check`). Un symlink\n * en un directorio que Ada ya escanea consigue lo mismo por CERO hunks.\n */\n\nimport { lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from \"node:fs\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { CONFIG_DIR_NAME } from \"../../config.ts\";\nimport { loadSkillsFromDir } from \"../skills.ts\";\n\nexport interface SkillDescubierta {\n\t/** De qué herramienta viene. */\n\torigen: string;\n\t/** Ruta al SKILL.md (o al .md suelto). */\n\truta: string;\n\t/** Carpeta que contiene el SKILL.md. */\n\tbaseDir: string;\n\tnombre: string;\n\tdescripcion: string;\n}\n\nexport interface ResultadoDescubrimientoSkills {\n\tskills: SkillDescubierta[];\n\t/** Directorios mirados, existan o no. */\n\tdirectoriosMirados: string[];\n\t/** SKILL.md que existían pero no pasaron el parseo/validación. */\n\terrores: Array<{ ruta: string; motivo: string }>;\n}\n\ninterface FuenteSkills {\n\torigen: string;\n\trelativa: string;\n}\n\nconst FUENTES: FuenteSkills[] = [\n\t{ origen: \"Claude Code\", relativa: \".claude/skills\" },\n\t{ origen: \"GitHub Copilot\", relativa: \".github/skills\" },\n];\n\nexport function descubrirSkills(cwd: string): ResultadoDescubrimientoSkills {\n\tconst skills: SkillDescubierta[] = [];\n\tconst directoriosMirados: string[] = [];\n\tconst errores: Array<{ ruta: string; motivo: string }> = [];\n\n\tfor (const fuente of FUENTES) {\n\t\tdirectoriosMirados.push(fuente.relativa);\n\t\tconst dir = join(cwd, fuente.relativa);\n\t\t// Directorio ausente: \"no hay\", `loadSkillsFromDir` devuelve vacío sin\n\t\t// diagnóstico. Un SKILL.md que existe pero no pasa el parseo SÍ genera uno:\n\t\t// esa es la diferencia entre \"no hay\" y \"no he podido\" que pide la regla 6.\n\t\tconst { skills: encontradas, diagnostics } = loadSkillsFromDir({ dir, source: `descubierta:${fuente.origen}` });\n\n\t\tfor (const skill of encontradas) {\n\t\t\tskills.push({\n\t\t\t\torigen: fuente.origen,\n\t\t\t\truta: skill.filePath,\n\t\t\t\tbaseDir: skill.baseDir,\n\t\t\t\tnombre: skill.name,\n\t\t\t\tdescripcion: skill.description,\n\t\t\t});\n\t\t}\n\t\tfor (const diagnostic of diagnostics) {\n\t\t\terrores.push({ ruta: diagnostic.path ?? dir, motivo: diagnostic.message });\n\t\t}\n\t}\n\n\treturn { skills, directoriosMirados, errores };\n}\n\nexport interface SkillInstalada {\n\tnombre: string;\n\torigen: string;\n\t/** El symlink creado (o ya existente) dentro de `.ada/skills`. */\n\tenlace: string;\n}\n\nfunction slugificar(texto: string): string {\n\treturn texto\n\t\t.toLowerCase()\n\t\t.replace(/[^a-z0-9]+/g, \"-\")\n\t\t.replace(/(^-+|-+$)/g, \"\");\n}\n\n/**\n * Deja `enlace` como symlink a `destino`. Devuelve false sin tocar nada si\n * `enlace` ya existe y NO es un symlink nuestro — nunca se borra un fichero\n * real que el usuario pueda tener ahí con el mismo nombre.\n */\nfunction asegurarEnlace(destino: string, enlace: string): boolean {\n\ttry {\n\t\tconst info = lstatSync(enlace);\n\t\tif (!info.isSymbolicLink()) return false;\n\t\tif (resolve(dirname(enlace), readlinkSync(enlace)) === destino) return true; // ya estaba\n\t\tunlinkSync(enlace);\n\t} catch {\n\t\t// no existe todavía: se crea abajo\n\t}\n\ttry {\n\t\tsymlinkSync(destino, enlace, \"dir\");\n\t\treturn true;\n\t} catch {\n\t\t// sistema de ficheros sin symlinks (o sin permiso): se queda sin instalar,\n\t\t// pero sigue apareciendo en `descubrirSkills` — listada, no disponible.\n\t\treturn false;\n\t}\n}\n\n/**\n * Enlaza cada skill descubierta dentro de `.ada/skills` para que la próxima\n * sesión (interactiva, `serve`, `acp`...) la cargue de verdad, sin que nadie\n * tenga que pasar `--skill` a mano.\n *\n * ponytail: no limpia symlinks de skills que dejaron de existir en origen.\n * Un symlink roto no rompe nada — `core/skills.ts` ya lo salta en silencio —\n * pero se queda ahí. Si el descuido empieza a notarse, un `discover --prune`\n * que borre los symlinks propios (prefijo `descubierta-`) que ya no resuelven\n * es la subida natural.\n */\nexport function instalarSkillsDescubiertas(cwd: string): SkillInstalada[] {\n\tconst { skills } = descubrirSkills(cwd);\n\tif (skills.length === 0) return [];\n\n\tconst destinoBase = join(cwd, CONFIG_DIR_NAME, \"skills\");\n\tmkdirSync(destinoBase, { recursive: true });\n\n\tconst instaladas: SkillInstalada[] = [];\n\tfor (const skill of skills) {\n\t\tconst slug = `descubierta-${slugificar(skill.origen)}-${basename(skill.baseDir)}`;\n\t\tconst enlace = join(destinoBase, slug);\n\t\tconst destino = resolve(skill.baseDir);\n\t\tif (asegurarEnlace(destino, enlace)) {\n\t\t\tinstaladas.push({ nombre: skill.nombre, origen: skill.origen, enlace });\n\t\t}\n\t}\n\treturn instaladas;\n}\n"]}

package/dist/core/dificultad/clasificador.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Presupuesto de razonamiento según la dificultad del turno.
+ *
+ * El nivel de pensamiento estaba fijo para toda la sesión: quien lo dejaba en
+ * `high` pagaba razonamiento extendido para preguntar «¿qué hace este
+ * fichero?», y quien lo dejaba en `low` pedía una refactorización completa con
+ * el presupuesto de una consulta. Las dos mitades cuestan dinero, una en
+ * tokens y la otra en calidad.
+ *
+ * Este clasificador decide el nivel a partir del texto del turno, SIN llamar
+ * al modelo: una llamada extra para decidir cuánto gastar se come el ahorro.
+ * Solo mira señales del propio texto (longitud, verbos de acción, ficheros
+ * mencionados, trazas de error).
+ *
+ * Tres estados, no dos, en las dos capas:
+ *   - `clasificar` devuelve `indeterminada` cuando NO PUEDE clasificar (texto
+ *     vacío, un comando de barra, o un turno de dos palabras sin ninguna
+ *     señal como «sigue»). No es «fácil»: es «no lo sé», y quien llama no
+ *     debe tocar nada.
+ *   - `decidirPresupuesto` devuelve una acción explícita (`inactivo`,
+ *     `cedido`, `sin-señal`, `sin-cambio`, `aplicar`) en vez de un nivel
+ *     opcional, para que «no toco nada porque el usuario mandó» no se lea
+ *     igual que «no toco nada porque ya está bien».
+ */
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+export type NivelDificultad = "indeterminada" | "trivial" | "media" | "alta";
+export interface Dificultad {
+    nivel: NivelDificultad;
+    /** Puntuación acumulada; negativa o cero es trivial. Útil para depurar el corpus. */
+    puntos: number;
+    /** Señales encontradas, en el orden en que se sumaron. Se enseñan al usuario. */
+    señales: string[];
+}
+/**
+ * Clasifica la dificultad de un turno. Función pura: mismo texto, misma salida.
+ *
+ * Devuelve `indeterminada` cuando no hay nada que clasificar. Un turno vacío,
+ * un comando de barra o un «sigue» de dos palabras no son «triviales»: no
+ * traen ninguna señal, y bajar el presupuesto por ellos sería decidir con una
+ * señal que no existe.
+ */
+export declare function clasificarDificultad(texto: string): Dificultad;
+/**
+ * Traduce la dificultad al nivel más cercano de los que el modelo soporta.
+ *
+ * No todos los modelos tienen los siete niveles; en caso de empate se elige el
+ * más barato, porque equivocarse hacia abajo cuesta menos que hacia arriba.
+ *
+ * El empate se resuelve mirando el ÍNDICE, no el orden de llegada. Quedarse
+ * con el primero solo da el más barato si `disponibles` viene ordenado de
+ * menor a mayor gasto — cierto hoy porque `getSupportedThinkingLevels` filtra
+ * `EXTENDED_THINKING_LEVELS` en ese orden, pero eso es una propiedad del
+ * llamante de hoy, no del contrato de esta función. Con `["high", "low"]` y
+ * dificultad media (ambos a distancia 1) devolvía `high`: lo caro, justo lo
+ * que el comentario prometía no hacer.
+ */
+export declare function nivelParaDificultad(dificultad: Exclude<NivelDificultad, "indeterminada">, disponibles: readonly ThinkingLevel[]): ThinkingLevel | null;
+/** Estado que sobrevive entre turnos de una misma sesión. */
+export interface EstadoPresupuesto {
+    /** Nivel efectivo que dejamos puesto la última vez. `null` = aún no hemos tocado nada. */
+    nivelPuestoPorNosotros: ThinkingLevel | null;
+    /** El usuario mandó a mano; no volvemos a decidir en esta sesión. */
+    cedido: boolean;
+}
+export declare function estadoInicial(): EstadoPresupuesto;
+export interface EntradaDecision {
+    texto: string;
+    nivelActual: ThinkingLevel;
+    disponibles: readonly ThinkingLevel[];
+    estado: EstadoPresupuesto;
+    activo: boolean;
+}
+export type DecisionDePresupuesto = {
+    accion: "inactivo";
+} | {
+    accion: "cedido";
+    motivo: "el usuario eligio el nivel a mano";
+} | {
+    accion: "sin-señal";
+    dificultad: Dificultad;
+} | {
+    accion: "sin-cambio";
+    dificultad: Dificultad;
+    nivel: ThinkingLevel;
+} | {
+    accion: "aplicar";
+    dificultad: Dificultad;
+    nivel: ThinkingLevel;
+    anterior: ThinkingLevel;
+};
+/**
+ * Decide qué hacer con el presupuesto de este turno.
+ *
+ * NO es pura: al detectar la cesión marca `entrada.estado.cedido`. La marca es
+ * necesaria — si solo dedujéramos la cesión comparando niveles, el usuario que
+ * cicla con shift+tab y vuelve a caer en el nivel que dejamos puesto haría que
+ * volviésemos a decidir por él. Aquí decía «sin efectos secundarios» y era
+ * falso; se corrige el comentario, no el código.
+ *
+ * La cesión es la puerta del usuario: en cuanto el nivel actual no es el que
+ * nosotros dejamos puesto, alguien lo cambió a mano entre turnos y dejamos de
+ * decidir para el resto de la sesión. Se detecta comparando nuestro propio
+ * estado, sin pedirle a upstream que nos avise de nada.
+ *
+ * El primer turno lo decidimos siempre. El nivel con el que arranca la sesión
+ * es una CONFIGURACIÓN (el default de settings, o el del modelo), no la
+ * intención de este turno — y es justo lo que este clasificador viene a
+ * sustituir. Lo que respetamos es el cambio explícito, que va acompañado del
+ * aviso visible que explica cómo desactivarnos.
+ */
+export declare function decidirPresupuesto(entrada: EntradaDecision): DecisionDePresupuesto;
+/** Texto que ve el usuario. El ajuste NO puede ser silencioso: cambia lo que paga. */
+export declare function mensajeDeDecision(decision: Extract<DecisionDePresupuesto, {
+    accion: "aplicar";
+}>): string;
+/** Puerto mínimo con la sesión. Lo justo para no importar `AgentSession` aquí. */
+export interface SesionAjustable {
+    nivelActual: ThinkingLevel;
+    disponibles: readonly ThinkingLevel[];
+    /** Aplica el nivel y devuelve el EFECTIVO (upstream lo recorta al modelo). */
+    fijar(nivel: ThinkingLevel): ThinkingLevel;
+    avisar(mensaje: string): void;
+}
+/**
+ * Punto de entrada desde `agent-session.prompt()`. Decide, aplica y avisa.
+ *
+ * Devuelve la decisión para que se pueda comprobar desde fuera: una función
+ * que solo tiene efectos secundarios es una función que nadie verifica.
+ */
+export declare function ajustarPresupuestoDeRazonamiento(clave: object, texto: string, sesion: SesionAjustable, env?: NodeJS.ProcessEnv): DecisionDePresupuesto;
+/** Solo para pruebas: olvida el estado de una sesión. */
+export declare function olvidarEstado(clave: object): void;
+//# sourceMappingURL=clasificador.d.ts.map

package/dist/core/dificultad/clasificador.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clasificador.d.ts","sourceRoot":"","sources":["../../../src/core/dificultad/clasificador.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAKnE,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAE7E,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,eAAe,CAAC;IACvB,uFAAqF;IACrF,MAAM,EAAE,MAAM,CAAC;IACf,mFAAiF;IACjF,QAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAyDD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAyE9D;AASD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,OAAO,CAAC,eAAe,EAAE,eAAe,CAAC,EACrD,WAAW,EAAE,SAAS,aAAa,EAAE,GACnC,aAAa,GAAG,IAAI,CAiBtB;AAED,8DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IACjC,4FAA0F;IAC1F,sBAAsB,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7C,uEAAqE;IACrE,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,wBAAgB,aAAa,IAAI,iBAAiB,CAEjD;AAED,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,aAAa,CAAC;IAC3B,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;IACtC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,qBAAqB,GAC9B;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,GACtB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,mCAAmC,CAAA;CAAE,GACjE;IAAE,MAAM,EAAE,YAAW,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,GAC/C;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GACtE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,qBAAqB,CAmBlF;AAED,sFAAsF;AACtF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC,GAAG,MAAM,CAGzG;AAED,qFAAkF;AAClF,MAAM,WAAW,eAAe;IAC/B,WAAW,EAAE,aAAa,CAAC;IAC3B,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;IACtC,8EAA8E;IAC9E,KAAK,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAAC;IAC3C,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAgBD;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAC/C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,eAAe,EACvB,GAAG,GAAE,MAAM,CAAC,UAAwB,GAClC,qBAAqB,CAiCvB;AAED,0DAAyD;AACzD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEjD","sourcesContent":["/**\n * Presupuesto de razonamiento según la dificultad del turno.\n *\n * El nivel de pensamiento estaba fijo para toda la sesión: quien lo dejaba en\n * `high` pagaba razonamiento extendido para preguntar «¿qué hace este\n * fichero?», y quien lo dejaba en `low` pedía una refactorización completa con\n * el presupuesto de una consulta. Las dos mitades cuestan dinero, una en\n * tokens y la otra en calidad.\n *\n * Este clasificador decide el nivel a partir del texto del turno, SIN llamar\n * al modelo: una llamada extra para decidir cuánto gastar se come el ahorro.\n * Solo mira señales del propio texto (longitud, verbos de acción, ficheros\n * mencionados, trazas de error).\n *\n * Tres estados, no dos, en las dos capas:\n *   - `clasificar` devuelve `indeterminada` cuando NO PUEDE clasificar (texto\n *     vacío, un comando de barra, o un turno de dos palabras sin ninguna\n *     señal como «sigue»). No es «fácil»: es «no lo sé», y quien llama no\n *     debe tocar nada.\n *   - `decidirPresupuesto` devuelve una acción explícita (`inactivo`,\n *     `cedido`, `sin-señal`, `sin-cambio`, `aplicar`) en vez de un nivel\n *     opcional, para que «no toco nada porque el usuario mandó» no se lea\n *     igual que «no toco nada porque ya está bien».\n */\n\nimport type { ThinkingLevel } from \"@earendil-works/pi-agent-core\";\n\n/** Orden canónico de menor a mayor gasto (el mismo de `EXTENDED_THINKING_LEVELS`). */\nconst ORDEN: string[] = [\"off\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"];\n\nexport type NivelDificultad = \"indeterminada\" | \"trivial\" | \"media\" | \"alta\";\n\nexport interface Dificultad {\n\tnivel: NivelDificultad;\n\t/** Puntuación acumulada; negativa o cero es trivial. Útil para depurar el corpus. */\n\tpuntos: number;\n\t/** Señales encontradas, en el orden en que se sumaron. Se enseñan al usuario. */\n\tseñales: string[];\n}\n\n/**\n * Verbos que implican cambiar el mundo (imperativo e infinitivo, y sus\n * equivalentes en inglés porque medio equipo escribe los prompts en inglés).\n * Se comparan sobre el texto normalizado sin acentos.\n *\n * Los troncos van sin la vocal final del tema («arregl», no «arregla») porque\n * la primera persona es una forma corriente en un turno y la que decide el\n * descuento por consulta directa de más abajo. Con «arregla\\w*» el ejemplo que\n * el propio comentario de ese descuento ponía —«cómo arreglo X»— no encontraba\n * ningún verbo, se llevaba el descuento entero y salía trivial: el comentario\n * decía una cosa y el código hacía la contraria.\n *\n * Los verbos corrientes del día a día («crea», «escribe», «haz», «mueve»,\n * «cambia», «quita», «revisa») faltaban por completo, y su ausencia NO era\n * neutra: sin ninguna señal el turno sumaba 0 puntos y 0 se leía como\n * «trivial», así que «crea un endpoint para facturas» bajaba el presupuesto a\n * `low`. El corpus de la primera versión no lo vio porque sus seis turnos\n * duros usaban justo los verbos de esta lista. Se arregla por los dos lados:\n * aquí, añadiéndolos, y abajo, no leyendo la ausencia de señal como facilidad.\n *\n * Estos van en formas ENUMERADAS, no en troncos, porque el tronco corto choca\n * con palabras que aparecen en consultas puras: «hac\\w*» se come el «hace» de\n * «¿qué hace este fichero?», «escrib\\w*» el «escribio» de «quién escribió\n * esto», y «cre\\w*» el «creo que» de cualquier frase dubitativa. Un falso\n * verbo ahí no solo sube el nivel: además anula el descuento por consulta\n * directa, que exige cero verbos.\n *\n * Techo conocido: sigue siendo una lista de troncos y formas a mano. Las\n * irregulares que no están aquí («rehago», «deshaz») se escapan. Si el corpus\n * de tráfico real lo pide, esto se cambia por un lematizador, no por más\n * troncos.\n */\nconst VERBOS_DE_ACCION =\n\t/\\b(refactoriz\\w*|reescrib\\w+|reimplement\\w+|implement\\w+|migra\\w*|arregl\\w*|corrig\\w+|corrij\\w+|correg\\w+|repar[aeo]\\w*|depur[aeo]\\w*|optimiz\\w*|integr[aeo]\\w*|disen\\w*|anade|anadir|agreg\\w*|elimin\\w*|borr[aeo]\\w*|renombr\\w*|actualiz\\w*|extra[ei]\\w*|divid\\w*|unific\\w*|automatiz\\w*|crea|crear|creame|escribe|escribir|escribeme|haz|hazme|hacer|genera|generar|construye|construir|soluciona|solucionar|resuelve|mueve|mover|traslada|trasladar|cambia|cambiar|convierte|convertir|separa|separar|quita|quitar|revisa|revisar|mejora|mejorar|simplifica|simplificar|documenta|documentar|valida|validar|reemplaza|reemplazar|sustituye|sustituir|refactor|rewrite|reimplement|implement|migrate|fix|debug|optimi[sz]e|integrate|redesign|refactoring|create|write|generate|solve|move|convert|split|replace|simplify|validate|review)\\b/g;\n\n/** Arranques de consulta pura: preguntan por algo que ya existe, no piden cambiarlo. */\nconst ARRANQUE_DE_CONSULTA =\n\t/^(que|cual|cuales|donde|como|quien|cuando|cuanto|para que|por que|what|which|where|how|who|when|why)\\b/;\n\n/** Trazas y mensajes de error pegados: casi siempre implican investigar. */\nconst SEÑAL_DE_ERROR =\n\t/(\\btraceback\\b|\\b\\w*error\\b\\s*:|\\bexception\\b|\\bpanic\\b|\\bsegfault\\b|\\bstack trace\\b|^\\s+at\\s+\\S+|\\bexit code\\s*[:=]?\\s*\\d+|\\bENOENT\\b|\\bECONNREFUSED\\b|\\bfailed to\\b|\\bassertionerror\\b)/im;\n\n/** Rutas y nombres de fichero con extensión conocida. */\nconst FICHERO =\n\t/\\b[\\w.@/-]+\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|rb|php|c|h|cpp|json|yaml|yml|toml|md|sh|sql|css|html)\\b/g;\n\n/** Quita acentos y baja a minúsculas para que las expresiones no lleven cada variante. */\nfunction normalizar(texto: string): string {\n\treturn texto\n\t\t.normalize(\"NFD\")\n\t\t.replace(/[\\u0300-\\u036f]/g, \"\")\n\t\t.toLowerCase();\n}\n\n/**\n * Clasifica la dificultad de un turno. Función pura: mismo texto, misma salida.\n *\n * Devuelve `indeterminada` cuando no hay nada que clasificar. Un turno vacío,\n * un comando de barra o un «sigue» de dos palabras no son «triviales»: no\n * traen ninguna señal, y bajar el presupuesto por ellos sería decidir con una\n * señal que no existe.\n */\nexport function clasificarDificultad(texto: string): Dificultad {\n\tconst crudo = texto.trim();\n\tif (crudo.length === 0 || crudo.startsWith(\"/\")) {\n\t\treturn { nivel: \"indeterminada\", puntos: 0, señales: [] };\n\t}\n\n\tconst t = normalizar(crudo);\n\tconst señales: string[] = [];\n\tlet puntos = 0;\n\n\tconst verbos = t.match(VERBOS_DE_ACCION) ?? [];\n\tif (verbos.length > 0) {\n\t\tconst suma = Math.min(verbos.length * 2, 4);\n\t\tpuntos += suma;\n\t\tseñales.push(verbos.length === 1 ? \"1 verbo de accion\" : `${verbos.length} verbos de accion`);\n\t}\n\n\tconst ficheros = new Set(crudo.match(FICHERO) ?? []);\n\tif (ficheros.size > 0) {\n\t\tpuntos += Math.min(ficheros.size, 3);\n\t\tseñales.push(ficheros.size === 1 ? \"1 fichero\" : `${ficheros.size} ficheros`);\n\t}\n\n\tif (SEÑAL_DE_ERROR.test(crudo)) {\n\t\tpuntos += 3;\n\t\tseñales.push(\"traza de error\");\n\t}\n\n\tif (crudo.length > 400) {\n\t\tpuntos += 2;\n\t\tseñales.push(\"turno largo\");\n\t} else if (crudo.length > 160) {\n\t\tpuntos += 1;\n\t\tseñales.push(\"turno medio\");\n\t}\n\n\t// Una lista de puntos o varias líneas es casi siempre varias tareas.\n\tconst lineas = crudo.split(\"\\n\").filter((l) => l.trim().length > 0);\n\tif (lineas.length >= 3 || /^\\s*(?:[-*]|\\d+[.)])\\s+/m.test(crudo)) {\n\t\tpuntos += 1;\n\t\tseñales.push(\"varias tareas\");\n\t}\n\n\t// Una consulta pura sin ningún verbo de acción se abarata a propósito.\n\t// Con verbo de acción no se descuenta: «cómo arreglo X» es trabajo, y por\n\t// eso los troncos de arriba tienen que cubrir la primera persona. Este\n\t// comentario decía ya esto mientras «cómo arreglo X» salía trivial.\n\tif (ARRANQUE_DE_CONSULTA.test(t.replace(/^[¿¡\\s]+/, \"\")) && verbos.length === 0) {\n\t\tpuntos -= 2;\n\t\tseñales.push(\"consulta directa\");\n\t}\n\n\t// CERO señales no es «fácil»: es «no lo sé». Sin esta puerta, `trivial` era\n\t// el valor por defecto de todo lo que la lista de verbos no reconocía, y la\n\t// lista nunca va a reconocerlo todo. Medido: de catorce turnos de trabajo\n\t// reales escritos con verbos corrientes («crea un endpoint», «mueve la\n\t// lógica de auth a su propio paquete», «revisa la seguridad del endpoint de\n\t// pagos»), los catorce salían `trivial` y se llevaban el presupuesto más\n\t// barato — exactamente el daño que este módulo dice venir a evitar. Lo\n\t// mismo con «sigue» detrás de una refactorización: el agente continuaba la\n\t// tarea dura con el presupuesto de una consulta.\n\t//\n\t// `trivial` pasa a exigir evidencia POSITIVA de que el turno es una\n\t// consulta (el descuento de arriba, o cualquier otra señal que deje los\n\t// puntos por debajo de cero). Sin ninguna señal no tocamos el presupuesto:\n\t// quedarse en el nivel de la sesión es el error barato; bajar a `low` una\n\t// tarea de refactorización es el caro.\n\tif (señales.length === 0) {\n\t\treturn { nivel: \"indeterminada\", puntos, señales };\n\t}\n\n\tconst nivel: NivelDificultad = puntos >= 4 ? \"alta\" : puntos >= 1 ? \"media\" : \"trivial\";\n\treturn { nivel, puntos, señales };\n}\n\n/** Nivel canónico que pediríamos para cada dificultad si el modelo los tuviera todos. */\nconst NIVEL_IDEAL: Record<Exclude<NivelDificultad, \"indeterminada\">, ThinkingLevel> = {\n\ttrivial: \"low\",\n\tmedia: \"medium\",\n\talta: \"high\",\n};\n\n/**\n * Traduce la dificultad al nivel más cercano de los que el modelo soporta.\n *\n * No todos los modelos tienen los siete niveles; en caso de empate se elige el\n * más barato, porque equivocarse hacia abajo cuesta menos que hacia arriba.\n *\n * El empate se resuelve mirando el ÍNDICE, no el orden de llegada. Quedarse\n * con el primero solo da el más barato si `disponibles` viene ordenado de\n * menor a mayor gasto — cierto hoy porque `getSupportedThinkingLevels` filtra\n * `EXTENDED_THINKING_LEVELS` en ese orden, pero eso es una propiedad del\n * llamante de hoy, no del contrato de esta función. Con `[\"high\", \"low\"]` y\n * dificultad media (ambos a distancia 1) devolvía `high`: lo caro, justo lo\n * que el comentario prometía no hacer.\n */\nexport function nivelParaDificultad(\n\tdificultad: Exclude<NivelDificultad, \"indeterminada\">,\n\tdisponibles: readonly ThinkingLevel[],\n): ThinkingLevel | null {\n\tif (disponibles.length === 0) return null;\n\tconst objetivo = ORDEN.indexOf(NIVEL_IDEAL[dificultad]);\n\tlet mejor: ThinkingLevel | null = null;\n\tlet mejorDistancia = Number.POSITIVE_INFINITY;\n\tlet mejorIndice = Number.POSITIVE_INFINITY;\n\tfor (const candidato of disponibles) {\n\t\tconst i = ORDEN.indexOf(candidato);\n\t\tif (i < 0) continue;\n\t\tconst distancia = Math.abs(i - objetivo);\n\t\tif (distancia < mejorDistancia || (distancia === mejorDistancia && i < mejorIndice)) {\n\t\t\tmejor = candidato;\n\t\t\tmejorDistancia = distancia;\n\t\t\tmejorIndice = i;\n\t\t}\n\t}\n\treturn mejor;\n}\n\n/** Estado que sobrevive entre turnos de una misma sesión. */\nexport interface EstadoPresupuesto {\n\t/** Nivel efectivo que dejamos puesto la última vez. `null` = aún no hemos tocado nada. */\n\tnivelPuestoPorNosotros: ThinkingLevel | null;\n\t/** El usuario mandó a mano; no volvemos a decidir en esta sesión. */\n\tcedido: boolean;\n}\n\nexport function estadoInicial(): EstadoPresupuesto {\n\treturn { nivelPuestoPorNosotros: null, cedido: false };\n}\n\nexport interface EntradaDecision {\n\ttexto: string;\n\tnivelActual: ThinkingLevel;\n\tdisponibles: readonly ThinkingLevel[];\n\testado: EstadoPresupuesto;\n\tactivo: boolean;\n}\n\nexport type DecisionDePresupuesto =\n\t| { accion: \"inactivo\" }\n\t| { accion: \"cedido\"; motivo: \"el usuario eligio el nivel a mano\" }\n\t| { accion: \"sin-señal\"; dificultad: Dificultad }\n\t| { accion: \"sin-cambio\"; dificultad: Dificultad; nivel: ThinkingLevel }\n\t| { accion: \"aplicar\"; dificultad: Dificultad; nivel: ThinkingLevel; anterior: ThinkingLevel };\n\n/**\n * Decide qué hacer con el presupuesto de este turno.\n *\n * NO es pura: al detectar la cesión marca `entrada.estado.cedido`. La marca es\n * necesaria — si solo dedujéramos la cesión comparando niveles, el usuario que\n * cicla con shift+tab y vuelve a caer en el nivel que dejamos puesto haría que\n * volviésemos a decidir por él. Aquí decía «sin efectos secundarios» y era\n * falso; se corrige el comentario, no el código.\n *\n * La cesión es la puerta del usuario: en cuanto el nivel actual no es el que\n * nosotros dejamos puesto, alguien lo cambió a mano entre turnos y dejamos de\n * decidir para el resto de la sesión. Se detecta comparando nuestro propio\n * estado, sin pedirle a upstream que nos avise de nada.\n *\n * El primer turno lo decidimos siempre. El nivel con el que arranca la sesión\n * es una CONFIGURACIÓN (el default de settings, o el del modelo), no la\n * intención de este turno — y es justo lo que este clasificador viene a\n * sustituir. Lo que respetamos es el cambio explícito, que va acompañado del\n * aviso visible que explica cómo desactivarnos.\n */\nexport function decidirPresupuesto(entrada: EntradaDecision): DecisionDePresupuesto {\n\tif (!entrada.activo) return { accion: \"inactivo\" };\n\n\tconst puesto = entrada.estado.nivelPuestoPorNosotros;\n\tif (entrada.estado.cedido || (puesto !== null && entrada.nivelActual !== puesto)) {\n\t\tentrada.estado.cedido = true;\n\t\treturn { accion: \"cedido\", motivo: \"el usuario eligio el nivel a mano\" };\n\t}\n\n\tconst dificultad = clasificarDificultad(entrada.texto);\n\tif (dificultad.nivel === \"indeterminada\") {\n\t\treturn { accion: \"sin-señal\", dificultad };\n\t}\n\n\tconst nivel = nivelParaDificultad(dificultad.nivel, entrada.disponibles);\n\tif (nivel === null || nivel === entrada.nivelActual) {\n\t\treturn { accion: \"sin-cambio\", dificultad, nivel: nivel ?? entrada.nivelActual };\n\t}\n\treturn { accion: \"aplicar\", dificultad, nivel, anterior: entrada.nivelActual };\n}\n\n/** Texto que ve el usuario. El ajuste NO puede ser silencioso: cambia lo que paga. */\nexport function mensajeDeDecision(decision: Extract<DecisionDePresupuesto, { accion: \"aplicar\" }>): string {\n\tconst señales = decision.dificultad.señales.length > 0 ? decision.dificultad.señales.join(\", \") : \"sin señales\";\n\treturn `Razonamiento automatico: ${decision.anterior} -> ${decision.nivel} (dificultad ${decision.dificultad.nivel}: ${señales}). Cambialo a mano para desactivarlo en esta sesion.`;\n}\n\n/** Puerto mínimo con la sesión. Lo justo para no importar `AgentSession` aquí. */\nexport interface SesionAjustable {\n\tnivelActual: ThinkingLevel;\n\tdisponibles: readonly ThinkingLevel[];\n\t/** Aplica el nivel y devuelve el EFECTIVO (upstream lo recorta al modelo). */\n\tfijar(nivel: ThinkingLevel): ThinkingLevel;\n\tavisar(mensaje: string): void;\n}\n\n/**\n * El estado vive aquí, indexado por la sesión, y no como campo de\n * `AgentSession`: declarar un campo privado en esa clase sería un hunk más\n * contra el presupuesto de fork, que está agotado (116/116). La sesión es la\n * clave; cuando se recolecta, su estado se va con ella.\n */\nconst estados = new WeakMap<object, EstadoPresupuesto>();\n\n/** El interruptor de escape, sin tocar `settings-manager.ts` (otro hunk de upstream). */\nfunction estaActivo(env: NodeJS.ProcessEnv): boolean {\n\tconst v = env.ADA_DIFICULTAD_AUTO;\n\treturn v !== \"0\" && v !== \"false\" && v !== \"no\";\n}\n\n/**\n * Punto de entrada desde `agent-session.prompt()`. Decide, aplica y avisa.\n *\n * Devuelve la decisión para que se pueda comprobar desde fuera: una función\n * que solo tiene efectos secundarios es una función que nadie verifica.\n */\nexport function ajustarPresupuestoDeRazonamiento(\n\tclave: object,\n\ttexto: string,\n\tsesion: SesionAjustable,\n\tenv: NodeJS.ProcessEnv = process.env,\n): DecisionDePresupuesto {\n\tlet estado = estados.get(clave);\n\tif (!estado) {\n\t\testado = estadoInicial();\n\t\testados.set(clave, estado);\n\t}\n\n\tconst decision = decidirPresupuesto({\n\t\ttexto,\n\t\tnivelActual: sesion.nivelActual,\n\t\tdisponibles: sesion.disponibles,\n\t\testado,\n\t\tactivo: estaActivo(env),\n\t});\n\n\tif (decision.accion === \"aplicar\") {\n\t\t// Guardamos el nivel EFECTIVO, no el pedido: upstream lo recorta a las\n\t\t// capacidades del modelo y, si guardáramos el pedido, el turno siguiente\n\t\t// vería una diferencia y cedería creyendo que fue el usuario.\n\t\testado.nivelPuestoPorNosotros = sesion.fijar(decision.nivel);\n\t\tsesion.avisar(mensajeDeDecision(decision));\n\t} else if (decision.accion === \"sin-cambio\" || decision.accion === \"sin-señal\") {\n\t\t// Un turno en el que NO cambiamos nada también hay que anotarlo: lo que\n\t\t// queda puesto es el nivel actual, y es contra ese valor contra el que\n\t\t// se detecta al usuario. Anotando solo al cambiar,\n\t\t// `nivelPuestoPorNosotros` se quedaba en null mientras el objetivo\n\t\t// coincidiera con el nivel de arranque, y la puerta de cesión no se\n\t\t// armaba nunca: sesión en `medium`, turno «arregla esto» (media ->\n\t\t// medium, sin-cambio), el usuario sube a `high` a mano y el turno\n\t\t// siguiente se lo bajaba a `low` sin ceder ni avisar de nada.\n\t\testado.nivelPuestoPorNosotros = sesion.nivelActual;\n\t}\n\treturn decision;\n}\n\n/** Solo para pruebas: olvida el estado de una sesión. */\nexport function olvidarEstado(clave: object): void {\n\testados.delete(clave);\n}\n"]}

package/dist/core/dificultad/clasificador.js

@@ -0,0 +1,288 @@
+/**
+ * Presupuesto de razonamiento según la dificultad del turno.
+ *
+ * El nivel de pensamiento estaba fijo para toda la sesión: quien lo dejaba en
+ * `high` pagaba razonamiento extendido para preguntar «¿qué hace este
+ * fichero?», y quien lo dejaba en `low` pedía una refactorización completa con
+ * el presupuesto de una consulta. Las dos mitades cuestan dinero, una en
+ * tokens y la otra en calidad.
+ *
+ * Este clasificador decide el nivel a partir del texto del turno, SIN llamar
+ * al modelo: una llamada extra para decidir cuánto gastar se come el ahorro.
+ * Solo mira señales del propio texto (longitud, verbos de acción, ficheros
+ * mencionados, trazas de error).
+ *
+ * Tres estados, no dos, en las dos capas:
+ *   - `clasificar` devuelve `indeterminada` cuando NO PUEDE clasificar (texto
+ *     vacío, un comando de barra, o un turno de dos palabras sin ninguna
+ *     señal como «sigue»). No es «fácil»: es «no lo sé», y quien llama no
+ *     debe tocar nada.
+ *   - `decidirPresupuesto` devuelve una acción explícita (`inactivo`,
+ *     `cedido`, `sin-señal`, `sin-cambio`, `aplicar`) en vez de un nivel
+ *     opcional, para que «no toco nada porque el usuario mandó» no se lea
+ *     igual que «no toco nada porque ya está bien».
+ */
+/** Orden canónico de menor a mayor gasto (el mismo de `EXTENDED_THINKING_LEVELS`). */
+const ORDEN = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/**
+ * Verbos que implican cambiar el mundo (imperativo e infinitivo, y sus
+ * equivalentes en inglés porque medio equipo escribe los prompts en inglés).
+ * Se comparan sobre el texto normalizado sin acentos.
+ *
+ * Los troncos van sin la vocal final del tema («arregl», no «arregla») porque
+ * la primera persona es una forma corriente en un turno y la que decide el
+ * descuento por consulta directa de más abajo. Con «arregla\w*» el ejemplo que
+ * el propio comentario de ese descuento ponía —«cómo arreglo X»— no encontraba
+ * ningún verbo, se llevaba el descuento entero y salía trivial: el comentario
+ * decía una cosa y el código hacía la contraria.
+ *
+ * Los verbos corrientes del día a día («crea», «escribe», «haz», «mueve»,
+ * «cambia», «quita», «revisa») faltaban por completo, y su ausencia NO era
+ * neutra: sin ninguna señal el turno sumaba 0 puntos y 0 se leía como
+ * «trivial», así que «crea un endpoint para facturas» bajaba el presupuesto a
+ * `low`. El corpus de la primera versión no lo vio porque sus seis turnos
+ * duros usaban justo los verbos de esta lista. Se arregla por los dos lados:
+ * aquí, añadiéndolos, y abajo, no leyendo la ausencia de señal como facilidad.
+ *
+ * Estos van en formas ENUMERADAS, no en troncos, porque el tronco corto choca
+ * con palabras que aparecen en consultas puras: «hac\w*» se come el «hace» de
+ * «¿qué hace este fichero?», «escrib\w*» el «escribio» de «quién escribió
+ * esto», y «cre\w*» el «creo que» de cualquier frase dubitativa. Un falso
+ * verbo ahí no solo sube el nivel: además anula el descuento por consulta
+ * directa, que exige cero verbos.
+ *
+ * Techo conocido: sigue siendo una lista de troncos y formas a mano. Las
+ * irregulares que no están aquí («rehago», «deshaz») se escapan. Si el corpus
+ * de tráfico real lo pide, esto se cambia por un lematizador, no por más
+ * troncos.
+ */
+const VERBOS_DE_ACCION = /\b(refactoriz\w*|reescrib\w+|reimplement\w+|implement\w+|migra\w*|arregl\w*|corrig\w+|corrij\w+|correg\w+|repar[aeo]\w*|depur[aeo]\w*|optimiz\w*|integr[aeo]\w*|disen\w*|anade|anadir|agreg\w*|elimin\w*|borr[aeo]\w*|renombr\w*|actualiz\w*|extra[ei]\w*|divid\w*|unific\w*|automatiz\w*|crea|crear|creame|escribe|escribir|escribeme|haz|hazme|hacer|genera|generar|construye|construir|soluciona|solucionar|resuelve|mueve|mover|traslada|trasladar|cambia|cambiar|convierte|convertir|separa|separar|quita|quitar|revisa|revisar|mejora|mejorar|simplifica|simplificar|documenta|documentar|valida|validar|reemplaza|reemplazar|sustituye|sustituir|refactor|rewrite|reimplement|implement|migrate|fix|debug|optimi[sz]e|integrate|redesign|refactoring|create|write|generate|solve|move|convert|split|replace|simplify|validate|review)\b/g;
+/** Arranques de consulta pura: preguntan por algo que ya existe, no piden cambiarlo. */
+const ARRANQUE_DE_CONSULTA = /^(que|cual|cuales|donde|como|quien|cuando|cuanto|para que|por que|what|which|where|how|who|when|why)\b/;
+/** Trazas y mensajes de error pegados: casi siempre implican investigar. */
+const SEÑAL_DE_ERROR = /(\btraceback\b|\b\w*error\b\s*:|\bexception\b|\bpanic\b|\bsegfault\b|\bstack trace\b|^\s+at\s+\S+|\bexit code\s*[:=]?\s*\d+|\bENOENT\b|\bECONNREFUSED\b|\bfailed to\b|\bassertionerror\b)/im;
+/** Rutas y nombres de fichero con extensión conocida. */
+const FICHERO = /\b[\w.@/-]+\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|rb|php|c|h|cpp|json|yaml|yml|toml|md|sh|sql|css|html)\b/g;
+/** Quita acentos y baja a minúsculas para que las expresiones no lleven cada variante. */
+function normalizar(texto) {
+    return texto
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+}
+/**
+ * Clasifica la dificultad de un turno. Función pura: mismo texto, misma salida.
+ *
+ * Devuelve `indeterminada` cuando no hay nada que clasificar. Un turno vacío,
+ * un comando de barra o un «sigue» de dos palabras no son «triviales»: no
+ * traen ninguna señal, y bajar el presupuesto por ellos sería decidir con una
+ * señal que no existe.
+ */
+export function clasificarDificultad(texto) {
+    const crudo = texto.trim();
+    if (crudo.length === 0 || crudo.startsWith("/")) {
+        return { nivel: "indeterminada", puntos: 0, señales: [] };
+    }
+    const t = normalizar(crudo);
+    const señales = [];
+    let puntos = 0;
+    const verbos = t.match(VERBOS_DE_ACCION) ?? [];
+    if (verbos.length > 0) {
+        const suma = Math.min(verbos.length * 2, 4);
+        puntos += suma;
+        señales.push(verbos.length === 1 ? "1 verbo de accion" : `${verbos.length} verbos de accion`);
+    }
+    const ficheros = new Set(crudo.match(FICHERO) ?? []);
+    if (ficheros.size > 0) {
+        puntos += Math.min(ficheros.size, 3);
+        señales.push(ficheros.size === 1 ? "1 fichero" : `${ficheros.size} ficheros`);
+    }
+    if (SEÑAL_DE_ERROR.test(crudo)) {
+        puntos += 3;
+        señales.push("traza de error");
+    }
+    if (crudo.length > 400) {
+        puntos += 2;
+        señales.push("turno largo");
+    }
+    else if (crudo.length > 160) {
+        puntos += 1;
+        señales.push("turno medio");
+    }
+    // Una lista de puntos o varias líneas es casi siempre varias tareas.
+    const lineas = crudo.split("\n").filter((l) => l.trim().length > 0);
+    if (lineas.length >= 3 || /^\s*(?:[-*]|\d+[.)])\s+/m.test(crudo)) {
+        puntos += 1;
+        señales.push("varias tareas");
+    }
+    // Una consulta pura sin ningún verbo de acción se abarata a propósito.
+    // Con verbo de acción no se descuenta: «cómo arreglo X» es trabajo, y por
+    // eso los troncos de arriba tienen que cubrir la primera persona. Este
+    // comentario decía ya esto mientras «cómo arreglo X» salía trivial.
+    if (ARRANQUE_DE_CONSULTA.test(t.replace(/^[¿¡\s]+/, "")) && verbos.length === 0) {
+        puntos -= 2;
+        señales.push("consulta directa");
+    }
+    // CERO señales no es «fácil»: es «no lo sé». Sin esta puerta, `trivial` era
+    // el valor por defecto de todo lo que la lista de verbos no reconocía, y la
+    // lista nunca va a reconocerlo todo. Medido: de catorce turnos de trabajo
+    // reales escritos con verbos corrientes («crea un endpoint», «mueve la
+    // lógica de auth a su propio paquete», «revisa la seguridad del endpoint de
+    // pagos»), los catorce salían `trivial` y se llevaban el presupuesto más
+    // barato — exactamente el daño que este módulo dice venir a evitar. Lo
+    // mismo con «sigue» detrás de una refactorización: el agente continuaba la
+    // tarea dura con el presupuesto de una consulta.
+    //
+    // `trivial` pasa a exigir evidencia POSITIVA de que el turno es una
+    // consulta (el descuento de arriba, o cualquier otra señal que deje los
+    // puntos por debajo de cero). Sin ninguna señal no tocamos el presupuesto:
+    // quedarse en el nivel de la sesión es el error barato; bajar a `low` una
+    // tarea de refactorización es el caro.
+    if (señales.length === 0) {
+        return { nivel: "indeterminada", puntos, señales };
+    }
+    const nivel = puntos >= 4 ? "alta" : puntos >= 1 ? "media" : "trivial";
+    return { nivel, puntos, señales };
+}
+/** Nivel canónico que pediríamos para cada dificultad si el modelo los tuviera todos. */
+const NIVEL_IDEAL = {
+    trivial: "low",
+    media: "medium",
+    alta: "high",
+};
+/**
+ * Traduce la dificultad al nivel más cercano de los que el modelo soporta.
+ *
+ * No todos los modelos tienen los siete niveles; en caso de empate se elige el
+ * más barato, porque equivocarse hacia abajo cuesta menos que hacia arriba.
+ *
+ * El empate se resuelve mirando el ÍNDICE, no el orden de llegada. Quedarse
+ * con el primero solo da el más barato si `disponibles` viene ordenado de
+ * menor a mayor gasto — cierto hoy porque `getSupportedThinkingLevels` filtra
+ * `EXTENDED_THINKING_LEVELS` en ese orden, pero eso es una propiedad del
+ * llamante de hoy, no del contrato de esta función. Con `["high", "low"]` y
+ * dificultad media (ambos a distancia 1) devolvía `high`: lo caro, justo lo
+ * que el comentario prometía no hacer.
+ */
+export function nivelParaDificultad(dificultad, disponibles) {
+    if (disponibles.length === 0)
+        return null;
+    const objetivo = ORDEN.indexOf(NIVEL_IDEAL[dificultad]);
+    let mejor = null;
+    let mejorDistancia = Number.POSITIVE_INFINITY;
+    let mejorIndice = Number.POSITIVE_INFINITY;
+    for (const candidato of disponibles) {
+        const i = ORDEN.indexOf(candidato);
+        if (i < 0)
+            continue;
+        const distancia = Math.abs(i - objetivo);
+        if (distancia < mejorDistancia || (distancia === mejorDistancia && i < mejorIndice)) {
+            mejor = candidato;
+            mejorDistancia = distancia;
+            mejorIndice = i;
+        }
+    }
+    return mejor;
+}
+export function estadoInicial() {
+    return { nivelPuestoPorNosotros: null, cedido: false };
+}
+/**
+ * Decide qué hacer con el presupuesto de este turno.
+ *
+ * NO es pura: al detectar la cesión marca `entrada.estado.cedido`. La marca es
+ * necesaria — si solo dedujéramos la cesión comparando niveles, el usuario que
+ * cicla con shift+tab y vuelve a caer en el nivel que dejamos puesto haría que
+ * volviésemos a decidir por él. Aquí decía «sin efectos secundarios» y era
+ * falso; se corrige el comentario, no el código.
+ *
+ * La cesión es la puerta del usuario: en cuanto el nivel actual no es el que
+ * nosotros dejamos puesto, alguien lo cambió a mano entre turnos y dejamos de
+ * decidir para el resto de la sesión. Se detecta comparando nuestro propio
+ * estado, sin pedirle a upstream que nos avise de nada.
+ *
+ * El primer turno lo decidimos siempre. El nivel con el que arranca la sesión
+ * es una CONFIGURACIÓN (el default de settings, o el del modelo), no la
+ * intención de este turno — y es justo lo que este clasificador viene a
+ * sustituir. Lo que respetamos es el cambio explícito, que va acompañado del
+ * aviso visible que explica cómo desactivarnos.
+ */
+export function decidirPresupuesto(entrada) {
+    if (!entrada.activo)
+        return { accion: "inactivo" };
+    const puesto = entrada.estado.nivelPuestoPorNosotros;
+    if (entrada.estado.cedido || (puesto !== null && entrada.nivelActual !== puesto)) {
+        entrada.estado.cedido = true;
+        return { accion: "cedido", motivo: "el usuario eligio el nivel a mano" };
+    }
+    const dificultad = clasificarDificultad(entrada.texto);
+    if (dificultad.nivel === "indeterminada") {
+        return { accion: "sin-señal", dificultad };
+    }
+    const nivel = nivelParaDificultad(dificultad.nivel, entrada.disponibles);
+    if (nivel === null || nivel === entrada.nivelActual) {
+        return { accion: "sin-cambio", dificultad, nivel: nivel ?? entrada.nivelActual };
+    }
+    return { accion: "aplicar", dificultad, nivel, anterior: entrada.nivelActual };
+}
+/** Texto que ve el usuario. El ajuste NO puede ser silencioso: cambia lo que paga. */
+export function mensajeDeDecision(decision) {
+    const señales = decision.dificultad.señales.length > 0 ? decision.dificultad.señales.join(", ") : "sin señales";
+    return `Razonamiento automatico: ${decision.anterior} -> ${decision.nivel} (dificultad ${decision.dificultad.nivel}: ${señales}). Cambialo a mano para desactivarlo en esta sesion.`;
+}
+/**
+ * El estado vive aquí, indexado por la sesión, y no como campo de
+ * `AgentSession`: declarar un campo privado en esa clase sería un hunk más
+ * contra el presupuesto de fork, que está agotado (116/116). La sesión es la
+ * clave; cuando se recolecta, su estado se va con ella.
+ */
+const estados = new WeakMap();
+/** El interruptor de escape, sin tocar `settings-manager.ts` (otro hunk de upstream). */
+function estaActivo(env) {
+    const v = env.ADA_DIFICULTAD_AUTO;
+    return v !== "0" && v !== "false" && v !== "no";
+}
+/**
+ * Punto de entrada desde `agent-session.prompt()`. Decide, aplica y avisa.
+ *
+ * Devuelve la decisión para que se pueda comprobar desde fuera: una función
+ * que solo tiene efectos secundarios es una función que nadie verifica.
+ */
+export function ajustarPresupuestoDeRazonamiento(clave, texto, sesion, env = process.env) {
+    let estado = estados.get(clave);
+    if (!estado) {
+        estado = estadoInicial();
+        estados.set(clave, estado);
+    }
+    const decision = decidirPresupuesto({
+        texto,
+        nivelActual: sesion.nivelActual,
+        disponibles: sesion.disponibles,
+        estado,
+        activo: estaActivo(env),
+    });
+    if (decision.accion === "aplicar") {
+        // Guardamos el nivel EFECTIVO, no el pedido: upstream lo recorta a las
+        // capacidades del modelo y, si guardáramos el pedido, el turno siguiente
+        // vería una diferencia y cedería creyendo que fue el usuario.
+        estado.nivelPuestoPorNosotros = sesion.fijar(decision.nivel);
+        sesion.avisar(mensajeDeDecision(decision));
+    }
+    else if (decision.accion === "sin-cambio" || decision.accion === "sin-señal") {
+        // Un turno en el que NO cambiamos nada también hay que anotarlo: lo que
+        // queda puesto es el nivel actual, y es contra ese valor contra el que
+        // se detecta al usuario. Anotando solo al cambiar,
+        // `nivelPuestoPorNosotros` se quedaba en null mientras el objetivo
+        // coincidiera con el nivel de arranque, y la puerta de cesión no se
+        // armaba nunca: sesión en `medium`, turno «arregla esto» (media ->
+        // medium, sin-cambio), el usuario sube a `high` a mano y el turno
+        // siguiente se lo bajaba a `low` sin ceder ni avisar de nada.
+        estado.nivelPuestoPorNosotros = sesion.nivelActual;
+    }
+    return decision;
+}
+/** Solo para pruebas: olvida el estado de una sesión. */
+export function olvidarEstado(clave) {
+    estados.delete(clave);
+}
+//# sourceMappingURL=clasificador.js.map