@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/aprobacion/politica-de-maquina.js

@@ -0,0 +1,212 @@
+/**
+ * El tercer ámbito de configuración: el que el usuario NO puede editar.
+ *
+ * EL AGUJERO, medido: `settings-manager.ts:203` declara
+ * `type SettingsScope = "global" | "project"`, y los dos ficheros son
+ * `~/<config>/agent/settings.json` y `<proyecto>/<config>/settings.json`. Los
+ * dos los escribe el usuario. Así que la línea que el CISO puso para prohibir
+ * `yolo` la borra el propio usuario con un editor de texto y `yolo` vuelve a
+ * estar disponible. Lo mismo en oh-my-pi, prime-agent y pi.dev: dos ámbitos,
+ * los dos suyos.
+ *
+ * Una política que el sujeto de la política puede desactivar no es una
+ * política. Es una sugerencia con formato JSON.
+ *
+ * LA PROPIEDAD QUE LA HACE REAL, y es la única que importa: esta política
+ * **solo puede restringir**. Nunca amplía. Si el fichero de máquina dice
+ * `modoMaximo: "manual"` y el usuario pide `yolo`, sale `manual`; si dice
+ * `modoMaximo: "yolo"` y el usuario pide `manual`, sale `manual` igual. Un
+ * ámbito que pudiera subir permisos sería un agujero nuevo —quien escriba en
+ * `/etc` ya tiene la máquina, pero quien copie un fichero de política de otro
+ * sitio no debería poder ampliarle los permisos a nadie—.
+ *
+ * DÓNDE VIVE. En el sitio de cada sistema que exige administrador para
+ * escribir, que es lo que sostiene todo lo demás:
+ *
+ *     macOS    /Library/Application Support/Ada/politica.json
+ *     Linux    /etc/ada/politica.json
+ *     Windows  %ProgramData%\Ada\politica.json
+ *
+ * LO QUE NO RESUELVE, dicho antes de que lo descubra un cliente: un usuario con
+ * administrador en su propia máquina puede editar el fichero. Esto no defiende
+ * de eso y no puede: en un equipo gestionado, quien tiene root manda. Defiende
+ * del caso que sí ocurre en una empresa —un portátil corporativo donde el
+ * empleado no es administrador— y deja constancia en el libro de sesión de bajo
+ * qué política se decidió cada llamada.
+ *
+ * Y si el fichero resulta ser escribible por el usuario, se dice. Una política
+ * que se aplica pero no protege es peor que ninguna si se presenta como que
+ * protege: se sigue aplicando —solo puede restringir, así que aplicarla nunca
+ * empeora— pero el aviso sale por `stderr` y por `ada-cli audit`.
+ */
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
+import { dirname, win32 } from "node:path";
+/** De menos a más permisivo. El orden ES la semántica del techo. */
+const ORDEN = ["plan", "manual", "auto", "yolo"];
+/** El sitio de cada sistema que pide administrador para escribir. */
+export function rutaDeLaPolitica(plataforma = process.platform, entorno = process.env) {
+    if (plataforma === "win32") {
+        // `win32.join` y no `join`: esta función recibe la plataforma como
+        // parámetro, así que tiene que dar la ruta correcta también cuando se la
+        // pregunta desde macOS o Linux. Con `join` a secas salía
+        // `D:\ProgramData/Ada/politica.json`, con los separadores mezclados.
+        return win32.join(entorno.ProgramData ?? "C:\\ProgramData", "Ada", "politica.json");
+    }
+    if (plataforma === "darwin") {
+        return "/Library/Application Support/Ada/politica.json";
+    }
+    return "/etc/ada/politica.json";
+}
+function esModo(x) {
+    return typeof x === "string" && ORDEN.includes(x);
+}
+/**
+ * Lee la política de máquina.
+ *
+ * Un fichero que existe y no se entiende NO se trata como que no existe: eso
+ * convertiría un error de sintaxis del administrador en una vía silenciosa para
+ * quedarse sin política. Se devuelve `ilegible`, y quien decide lo baja a lo
+ * más restrictivo — igual que hace `nivelDesdeConfig` con un nivel desconocido.
+ */
+export function leerPoliticaDeMaquina(ruta = rutaDeLaPolitica()) {
+    let crudo;
+    try {
+        crudo = readFileSync(ruta, "utf-8");
+    }
+    catch (error) {
+        const codigo = error.code;
+        if (codigo === "ENOENT") {
+            return { politica: null, ruta, estado: "ausente", editablePorElUsuario: false, aviso: "" };
+        }
+        // Existe pero no se deja leer —permisos, por ejemplo—. «No he podido
+        // mirarlo» no es «no hay nada».
+        return {
+            politica: null,
+            ruta,
+            estado: "ilegible",
+            editablePorElUsuario: false,
+            aviso: `hay una política de máquina en ${ruta} y no se ha podido leer (${codigo ?? "error"})`,
+        };
+    }
+    let objeto;
+    try {
+        objeto = JSON.parse(crudo);
+    }
+    catch {
+        return {
+            politica: null,
+            ruta,
+            estado: "ilegible",
+            editablePorElUsuario: false,
+            aviso: `la política de máquina de ${ruta} no es JSON válido`,
+        };
+    }
+    if (typeof objeto !== "object" || objeto === null) {
+        return {
+            politica: null,
+            ruta,
+            estado: "ilegible",
+            editablePorElUsuario: false,
+            aviso: `la política de máquina de ${ruta} no es un objeto`,
+        };
+    }
+    const o = objeto;
+    // Un `modoMaximo` que no se entiende es lo mismo que no poder leer el
+    // fichero: si se ignorara, bastaría una errata para desactivar el techo.
+    if (o.modoMaximo !== undefined && !esModo(o.modoMaximo)) {
+        return {
+            politica: null,
+            ruta,
+            estado: "ilegible",
+            editablePorElUsuario: false,
+            aviso: `"modoMaximo" vale ${JSON.stringify(o.modoMaximo)} en ${ruta}, y no es ninguno de ${ORDEN.join(", ")}`,
+        };
+    }
+    const politica = {
+        ...(esModo(o.modoMaximo) ? { modoMaximo: o.modoMaximo } : {}),
+        ...(Array.isArray(o.denegadas)
+            ? { denegadas: o.denegadas.filter((x) => typeof x === "string") }
+            : {}),
+        ...(typeof o.motivo === "string" ? { motivo: o.motivo } : {}),
+    };
+    const editable = escribiblePorElUsuario(ruta);
+    return {
+        politica,
+        ruta,
+        estado: "aplicada",
+        editablePorElUsuario: editable,
+        aviso: editable
+            ? `la política de máquina de ${ruta} la puede editar este usuario, así que no garantiza nada`
+            : "",
+    };
+}
+/**
+ * ¿Puede este usuario reescribir el fichero de política?
+ *
+ * Se comprueba el fichero Y su directorio: poder escribir en el directorio
+ * basta para sustituir el fichero entero, y mirar solo el fichero daría por
+ * protegida una política que cualquiera puede reemplazar.
+ */
+function escribiblePorElUsuario(ruta) {
+    const puedeEscribir = (p) => {
+        try {
+            accessSync(p, constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (puedeEscribir(ruta))
+        return true;
+    try {
+        // `dirname` y no partir por "/" a mano: esta comprobación sí corre en la
+        // máquina de verdad, y en Windows el separador es el otro.
+        const dir = dirname(ruta);
+        statSync(dir);
+        return puedeEscribir(dir);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Aplica el techo. **Solo baja.**
+ *
+ * `ilegible` cae a `manual`, el más restrictivo utilizable: un fichero de
+ * política que el administrador escribió mal no puede acabar dando MÁS permisos
+ * de los que él pretendía. `plan` no se usa como caída porque dejaría el agente
+ * sin poder actuar en absoluto por una coma mal puesta.
+ */
+export function recortarModo(pedido, lectura) {
+    if (lectura.estado === "ausente")
+        return pedido;
+    if (lectura.estado === "ilegible") {
+        return ORDEN.indexOf(pedido) < ORDEN.indexOf("manual") ? pedido : "manual";
+    }
+    const techo = lectura.politica?.modoMaximo;
+    if (!techo)
+        return pedido;
+    return ORDEN.indexOf(pedido) <= ORDEN.indexOf(techo) ? pedido : techo;
+}
+/**
+ * La política leída una vez por proceso.
+ *
+ * Se lee perezosamente —en la primera decisión, no al importar— porque el
+ * arranque tiene puerta medida (`scripts/check-arranque.mjs`) y un `readFileSync`
+ * en tiempo de importación se paga en cada `--version`.
+ */
+let cacheada = null;
+export function politicaDeMaquina() {
+    if (!cacheada) {
+        cacheada = leerPoliticaDeMaquina();
+        if (cacheada.aviso)
+            console.error(`Ada: ${cacheada.aviso}.`);
+    }
+    return cacheada;
+}
+/** Para las pruebas: vuelve a leer la próxima vez. */
+export function olvidarPoliticaDeMaquina() {
+    cacheada = null;
+}
+//# sourceMappingURL=politica-de-maquina.js.map

package/dist/core/aprobacion/politica-de-maquina.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"politica-de-maquina.js","sourceRoot":"","sources":["../../../src/core/aprobacion/politica-de-maquina.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * El tercer ámbito de configuración: el que el usuario NO puede editar.\n *\n * EL AGUJERO, medido: `settings-manager.ts:203` declara\n * `type SettingsScope = \"global\" | \"project\"`, y los dos ficheros son\n * `~/<config>/agent/settings.json` y `<proyecto>/<config>/settings.json`. Los\n * dos los escribe el usuario. Así que la línea que el CISO puso para prohibir\n * `yolo` la borra el propio usuario con un editor de texto y `yolo` vuelve a\n * estar disponible. Lo mismo en oh-my-pi, prime-agent y pi.dev: dos ámbitos,\n * los dos suyos.\n *\n * Una política que el sujeto de la política puede desactivar no es una\n * política. Es una sugerencia con formato JSON.\n *\n * LA PROPIEDAD QUE LA HACE REAL, y es la única que importa: esta política\n * **solo puede restringir**. Nunca amplía. Si el fichero de máquina dice\n * `modoMaximo: \"manual\"` y el usuario pide `yolo`, sale `manual`; si dice\n * `modoMaximo: \"yolo\"` y el usuario pide `manual`, sale `manual` igual. Un\n * ámbito que pudiera subir permisos sería un agujero nuevo —quien escriba en\n * `/etc` ya tiene la máquina, pero quien copie un fichero de política de otro\n * sitio no debería poder ampliarle los permisos a nadie—.\n *\n * DÓNDE VIVE. En el sitio de cada sistema que exige administrador para\n * escribir, que es lo que sostiene todo lo demás:\n *\n *     macOS    /Library/Application Support/Ada/politica.json\n *     Linux    /etc/ada/politica.json\n *     Windows  %ProgramData%\\Ada\\politica.json\n *\n * LO QUE NO RESUELVE, dicho antes de que lo descubra un cliente: un usuario con\n * administrador en su propia máquina puede editar el fichero. Esto no defiende\n * de eso y no puede: en un equipo gestionado, quien tiene root manda. Defiende\n * del caso que sí ocurre en una empresa —un portátil corporativo donde el\n * empleado no es administrador— y deja constancia en el libro de sesión de bajo\n * qué política se decidió cada llamada.\n *\n * Y si el fichero resulta ser escribible por el usuario, se dice. Una política\n * que se aplica pero no protege es peor que ninguna si se presenta como que\n * protege: se sigue aplicando —solo puede restringir, así que aplicarla nunca\n * empeora— pero el aviso sale por `stderr` y por `ada-cli audit`.\n */\n\nimport { accessSync, constants, readFileSync, statSync } from \"node:fs\";\nimport { dirname, win32 } from \"node:path\";\nimport type { ModoPermiso } from \"./politica.ts\";\n\n/** De menos a más permisivo. El orden ES la semántica del techo. */\nconst ORDEN: readonly ModoPermiso[] = [\"plan\", \"manual\", \"auto\", \"yolo\"];\n\nexport interface PoliticaDeMaquina {\n\t/** Techo del modo de permisos. Nunca sube el del usuario, solo lo baja. */\n\tmodoMaximo?: ModoPermiso;\n\t/** Tools denegadas para todo el equipo. Se suman a las del usuario. */\n\tdenegadas?: string[];\n\t/** Qué contarle a quien se topa con el bloqueo. Va al mensaje del modelo. */\n\tmotivo?: string;\n}\n\n/** Qué se leyó y qué garantía tiene. Nunca «no hay» cuando es «no pude». */\nexport interface LecturaDePolitica {\n\tpolitica: PoliticaDeMaquina | null;\n\truta: string;\n\t/**\n\t * Tres estados y no dos:\n\t *   · `ausente`      — no hay fichero. No hay política, y eso es una respuesta.\n\t *   · `aplicada`     — leído y en vigor.\n\t *   · `ilegible`     — existe y no se ha podido leer o entender. NO es «no hay».\n\t */\n\testado: \"ausente\" | \"aplicada\" | \"ilegible\";\n\t/** `true` si el usuario puede escribir el fichero: entonces no garantiza nada. */\n\teditablePorElUsuario: boolean;\n\t/** Explicación para el aviso. Vacía cuando no hay nada que decir. */\n\taviso: string;\n}\n\n/** El sitio de cada sistema que pide administrador para escribir. */\nexport function rutaDeLaPolitica(plataforma: NodeJS.Platform = process.platform, entorno = process.env): string {\n\tif (plataforma === \"win32\") {\n\t\t// `win32.join` y no `join`: esta función recibe la plataforma como\n\t\t// parámetro, así que tiene que dar la ruta correcta también cuando se la\n\t\t// pregunta desde macOS o Linux. Con `join` a secas salía\n\t\t// `D:\\ProgramData/Ada/politica.json`, con los separadores mezclados.\n\t\treturn win32.join(entorno.ProgramData ?? \"C:\\\\ProgramData\", \"Ada\", \"politica.json\");\n\t}\n\tif (plataforma === \"darwin\") {\n\t\treturn \"/Library/Application Support/Ada/politica.json\";\n\t}\n\treturn \"/etc/ada/politica.json\";\n}\n\nfunction esModo(x: unknown): x is ModoPermiso {\n\treturn typeof x === \"string\" && (ORDEN as readonly string[]).includes(x);\n}\n\n/**\n * Lee la política de máquina.\n *\n * Un fichero que existe y no se entiende NO se trata como que no existe: eso\n * convertiría un error de sintaxis del administrador en una vía silenciosa para\n * quedarse sin política. Se devuelve `ilegible`, y quien decide lo baja a lo\n * más restrictivo — igual que hace `nivelDesdeConfig` con un nivel desconocido.\n */\nexport function leerPoliticaDeMaquina(ruta = rutaDeLaPolitica()): LecturaDePolitica {\n\tlet crudo: string;\n\ttry {\n\t\tcrudo = readFileSync(ruta, \"utf-8\");\n\t} catch (error) {\n\t\tconst codigo = (error as NodeJS.ErrnoException).code;\n\t\tif (codigo === \"ENOENT\") {\n\t\t\treturn { politica: null, ruta, estado: \"ausente\", editablePorElUsuario: false, aviso: \"\" };\n\t\t}\n\t\t// Existe pero no se deja leer —permisos, por ejemplo—. «No he podido\n\t\t// mirarlo» no es «no hay nada».\n\t\treturn {\n\t\t\tpolitica: null,\n\t\t\truta,\n\t\t\testado: \"ilegible\",\n\t\t\teditablePorElUsuario: false,\n\t\t\taviso: `hay una política de máquina en ${ruta} y no se ha podido leer (${codigo ?? \"error\"})`,\n\t\t};\n\t}\n\n\tlet objeto: unknown;\n\ttry {\n\t\tobjeto = JSON.parse(crudo);\n\t} catch {\n\t\treturn {\n\t\t\tpolitica: null,\n\t\t\truta,\n\t\t\testado: \"ilegible\",\n\t\t\teditablePorElUsuario: false,\n\t\t\taviso: `la política de máquina de ${ruta} no es JSON válido`,\n\t\t};\n\t}\n\tif (typeof objeto !== \"object\" || objeto === null) {\n\t\treturn {\n\t\t\tpolitica: null,\n\t\t\truta,\n\t\t\testado: \"ilegible\",\n\t\t\teditablePorElUsuario: false,\n\t\t\taviso: `la política de máquina de ${ruta} no es un objeto`,\n\t\t};\n\t}\n\n\tconst o = objeto as Record<string, unknown>;\n\t// Un `modoMaximo` que no se entiende es lo mismo que no poder leer el\n\t// fichero: si se ignorara, bastaría una errata para desactivar el techo.\n\tif (o.modoMaximo !== undefined && !esModo(o.modoMaximo)) {\n\t\treturn {\n\t\t\tpolitica: null,\n\t\t\truta,\n\t\t\testado: \"ilegible\",\n\t\t\teditablePorElUsuario: false,\n\t\t\taviso: `\"modoMaximo\" vale ${JSON.stringify(o.modoMaximo)} en ${ruta}, y no es ninguno de ${ORDEN.join(\", \")}`,\n\t\t};\n\t}\n\n\tconst politica: PoliticaDeMaquina = {\n\t\t...(esModo(o.modoMaximo) ? { modoMaximo: o.modoMaximo } : {}),\n\t\t...(Array.isArray(o.denegadas)\n\t\t\t? { denegadas: o.denegadas.filter((x): x is string => typeof x === \"string\") }\n\t\t\t: {}),\n\t\t...(typeof o.motivo === \"string\" ? { motivo: o.motivo } : {}),\n\t};\n\n\tconst editable = escribiblePorElUsuario(ruta);\n\treturn {\n\t\tpolitica,\n\t\truta,\n\t\testado: \"aplicada\",\n\t\teditablePorElUsuario: editable,\n\t\taviso: editable\n\t\t\t? `la política de máquina de ${ruta} la puede editar este usuario, así que no garantiza nada`\n\t\t\t: \"\",\n\t};\n}\n\n/**\n * ¿Puede este usuario reescribir el fichero de política?\n *\n * Se comprueba el fichero Y su directorio: poder escribir en el directorio\n * basta para sustituir el fichero entero, y mirar solo el fichero daría por\n * protegida una política que cualquiera puede reemplazar.\n */\nfunction escribiblePorElUsuario(ruta: string): boolean {\n\tconst puedeEscribir = (p: string): boolean => {\n\t\ttry {\n\t\t\taccessSync(p, constants.W_OK);\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t};\n\tif (puedeEscribir(ruta)) return true;\n\ttry {\n\t\t// `dirname` y no partir por \"/\" a mano: esta comprobación sí corre en la\n\t\t// máquina de verdad, y en Windows el separador es el otro.\n\t\tconst dir = dirname(ruta);\n\t\tstatSync(dir);\n\t\treturn puedeEscribir(dir);\n\t} catch {\n\t\treturn false;\n\t}\n}\n\n/**\n * Aplica el techo. **Solo baja.**\n *\n * `ilegible` cae a `manual`, el más restrictivo utilizable: un fichero de\n * política que el administrador escribió mal no puede acabar dando MÁS permisos\n * de los que él pretendía. `plan` no se usa como caída porque dejaría el agente\n * sin poder actuar en absoluto por una coma mal puesta.\n */\nexport function recortarModo(pedido: ModoPermiso, lectura: LecturaDePolitica): ModoPermiso {\n\tif (lectura.estado === \"ausente\") return pedido;\n\tif (lectura.estado === \"ilegible\") {\n\t\treturn ORDEN.indexOf(pedido) < ORDEN.indexOf(\"manual\") ? pedido : \"manual\";\n\t}\n\tconst techo = lectura.politica?.modoMaximo;\n\tif (!techo) return pedido;\n\treturn ORDEN.indexOf(pedido) <= ORDEN.indexOf(techo) ? pedido : techo;\n}\n\n/**\n * La política leída una vez por proceso.\n *\n * Se lee perezosamente —en la primera decisión, no al importar— porque el\n * arranque tiene puerta medida (`scripts/check-arranque.mjs`) y un `readFileSync`\n * en tiempo de importación se paga en cada `--version`.\n */\nlet cacheada: LecturaDePolitica | null = null;\n\nexport function politicaDeMaquina(): LecturaDePolitica {\n\tif (!cacheada) {\n\t\tcacheada = leerPoliticaDeMaquina();\n\t\tif (cacheada.aviso) console.error(`Ada: ${cacheada.aviso}.`);\n\t}\n\treturn cacheada;\n}\n\n/** Para las pruebas: vuelve a leer la próxima vez. */\nexport function olvidarPoliticaDeMaquina(): void {\n\tcacheada = null;\n}\n"]}

package/dist/core/aprobacion/politica.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Aprobación por herramienta.
+ *
+ * Antes de esto no había política ninguna: `beforeToolCall` disparaba los hooks
+ * del usuario y las extensiones, y `permissions.level` —que existe en settings
+ * desde siempre— solo lo leían los propios hooks. Ninguna tool se consultaba
+ * contra él. Es decir, el nivel de permisos no gobernaba los permisos.
+ *
+ * El orden de las comprobaciones ES la propiedad de seguridad, y por eso está
+ * escrito de arriba abajo en `decidir()` y no repartido:
+ *
+ *   1. Rutas protegidas   — denegado SIEMPRE, incluso en `yolo`, no configurable
+ *   2. Deny del usuario   — denegado SIEMPRE, incluso en `yolo`
+ *   3. Modo de la sesión  — plan / manual / auto / yolo
+ *
+ * Que 1 y 2 vayan por delante del modo es lo que hace que el argumento de
+ * cumplimiento se sostenga: una política que el propio agente puede desactivar
+ * pidiendo `yolo` no es una política, es una sugerencia.
+ *
+ * Lo desconocido cuenta como ejecución. Una tool de MCP o de una extensión que
+ * nadie ha clasificado no puede colarse por el carril de lectura por no estar
+ * en ninguna lista.
+ */
+import { type LecturaDePolitica } from "./politica-de-maquina.ts";
+export type NivelTool = "lectura" | "escritura" | "ejecucion";
+export type ModoPermiso = "plan" | "manual" | "auto" | "yolo";
+export type VeredictoAprobacion = "permitida" | "denegada" | "preguntar";
+export interface Decision {
+    veredicto: VeredictoAprobacion;
+    /** Qué regla decidió. Va al libro de sesión, así que tiene que ser estable. */
+    politica: string;
+    /** Texto para el modelo y para el usuario. Vacío cuando no hay nada que explicar. */
+    motivo: string;
+}
+/**
+ * ¿Este nombre es de una tool NUESTRA cuyo nivel de confianza da esta política?
+ *
+ * Lo consulta el registro de extensiones para saber si `registerTool` está
+ * suplantando una builtin. `bash` va aparte porque no está en ninguna de las dos
+ * listas —lo desconocido ya es ejecución— pero suplantarlo importa igual: el
+ * usuario tiene que ver que el `bash` que corre no es el nuestro.
+ */
+export declare function esNombreDeToolNuestra(tool: string): boolean;
+/**
+ * El nivel de una herramienta. Lo que no está clasificado es ejecución.
+ *
+ * Falla cerrado a propósito: el coste de equivocarse hacia arriba es una
+ * pregunta de más; hacia abajo, es una tool desconocida corriendo sola.
+ */
+export declare function nivelDe(tool: string): NivelTool;
+export interface EntradaDecision {
+    tool: string;
+    args: Record<string, unknown>;
+    modo: ModoPermiso;
+    agentDir: string;
+    /**
+     * Directorio del usuario, para resolver `~` y `$HOME` antes de comparar.
+     *
+     * Opcional y con `homedir()` por defecto para que el punto de llamada no
+     * tenga que importarlo: `agent-session.ts` es de upstream y está en el tope
+     * del presupuesto de fork, donde un `import` nuevo cuesta un hunk. Las
+     * pruebas lo pasan siempre, así que siguen siendo deterministas.
+     */
+    home?: string;
+    /** Tools que el usuario ha denegado explícitamente en su configuración. */
+    denegadas?: string[];
+    /**
+     * La política de máquina, para las pruebas.
+     *
+     * Opcional, y por defecto la del sistema. NO se lee de una variable de
+     * entorno a propósito: una variable la pone el propio usuario, así que sería
+     * la puerta trasera que anula toda la política de un `export`. Quien ya
+     * ejecuta código en este proceso puede saltársela igual —la frontera es el
+     * proceso, no esta función—, pero no debe haber un camino cómodo.
+     */
+    maquina?: LecturaDePolitica;
+}
+/**
+ * Lee `permissions.denied` de la configuración, tolerando que no exista.
+ *
+ * El bloque `permissions` es un `Record<string, unknown>` en settings, así que
+ * lo que hay ahí no está tipado y puede ser cualquier cosa: se filtra a cadenas
+ * en vez de confiar. Una entrada mal escrita tiene que perderse ella sola, no
+ * tumbar la política entera y con ella la sesión.
+ */
+export declare function leerDenegadas(config: {
+    permissions?: Record<string, unknown>;
+} | undefined): string[];
+export declare function decidir({ tool, args, modo, agentDir, home, denegadas, maquina: maquinaDada }: EntradaDecision): Decision;
+//# sourceMappingURL=politica.d.ts.map

package/dist/core/aprobacion/politica.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"politica.d.ts","sourceRoot":"","sources":["../../../src/core/aprobacion/politica.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAQH,OAAO,EAAE,KAAK,iBAAiB,EAAmC,MAAM,0BAA0B,CAAC;AAenG,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAEzE,MAAM,WAAW,QAAQ;IACxB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,mFAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IACjB,sFAAqF;IACrF,MAAM,EAAE,MAAM,CAAC;CACf;AAkCD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAY/C;AAmJD,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,SAAS,GAAG,MAAM,EAAE,CAGrG;AAED,wBAAgB,OAAO,CAAC,EACvB,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,OAAO,EAAE,WAAW,EACpB,EAAE,eAAe,GAAG,QAAQ,CA4G5B","sourcesContent":["/**\n * Aprobación por herramienta.\n *\n * Antes de esto no había política ninguna: `beforeToolCall` disparaba los hooks\n * del usuario y las extensiones, y `permissions.level` —que existe en settings\n * desde siempre— solo lo leían los propios hooks. Ninguna tool se consultaba\n * contra él. Es decir, el nivel de permisos no gobernaba los permisos.\n *\n * El orden de las comprobaciones ES la propiedad de seguridad, y por eso está\n * escrito de arriba abajo en `decidir()` y no repartido:\n *\n *   1. Rutas protegidas   — denegado SIEMPRE, incluso en `yolo`, no configurable\n *   2. Deny del usuario   — denegado SIEMPRE, incluso en `yolo`\n *   3. Modo de la sesión  — plan / manual / auto / yolo\n *\n * Que 1 y 2 vayan por delante del modo es lo que hace que el argumento de\n * cumplimiento se sostenga: una política que el propio agente puede desactivar\n * pidiendo `yolo` no es una política, es una sugerencia.\n *\n * Lo desconocido cuenta como ejecución. Una tool de MCP o de una extensión que\n * nadie ha clasificado no puede colarse por el carril de lectura por no estar\n * en ninguna lista.\n */\n\nimport { readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { CONFIG_DIR_NAME } from \"../../config.ts\";\nimport { DIR_INDICE, DIR_SESION } from \"../audit/rutas.ts\";\nimport { suplantadaPor } from \"../extensiones/suplantacion.ts\";\nimport { marcaDeGenerado, motivoDeGenerado } from \"./generados.ts\";\nimport { type LecturaDePolitica, politicaDeMaquina, recortarModo } from \"./politica-de-maquina.ts\";\n\n/**\n * Segmento `.../<CONFIG_DIR_NAME>/agent/` de CUALQUIER instalación de Ada,\n * no solo `agentDir` (que es la de ESTE equipo).\n *\n * Con `--remoto` los argumentos de `read`/`write`/`bash` pueden nombrar un\n * `auth.json` o un `vault/` que viven en OTRA máquina — el destino de SSH,\n * el contenedor de Docker, la distro de WSL — con su propio `$HOME` y por\n * tanto un `agentDir` que `rutaProtegida` nunca conoce. Comprobar el\n * segmento en vez del prefijo completo protege ambos sin necesitar el\n * `agentDir` del destino, que esta política no tiene forma de calcular.\n */\nconst SEGMENTO_AGENTE_ADA = `/${CONFIG_DIR_NAME}/agent/`;\n\nexport type NivelTool = \"lectura\" | \"escritura\" | \"ejecucion\";\nexport type ModoPermiso = \"plan\" | \"manual\" | \"auto\" | \"yolo\";\nexport type VeredictoAprobacion = \"permitida\" | \"denegada\" | \"preguntar\";\n\nexport interface Decision {\n\tveredicto: VeredictoAprobacion;\n\t/** Qué regla decidió. Va al libro de sesión, así que tiene que ser estable. */\n\tpolitica: string;\n\t/** Texto para el modelo y para el usuario. Vacío cuando no hay nada que explicar. */\n\tmotivo: string;\n}\n\n/** Tools que solo miran. */\nconst LECTURA = new Set([\n\t\"read\",\n\t\"ls\",\n\t\"find\",\n\t\"grep\",\n\t\"ast_search\",\n\t\"session_search\",\n\t\"web_fetch\",\n\t\"web_search\",\n\t\"memory_search\",\n\t\"memory_list\",\n\t\"graph_query\",\n\t\"ask_user_question\",\n\t\"todo_read\",\n]);\n\n/** Tools que cambian estado nuestro, pero no ejecutan nada del sistema. */\nconst ESCRITURA = new Set([\n\t\"edit\",\n\t\"write\",\n\t\"ast_edit\",\n\t\"memory_add\",\n\t\"memory_replace\",\n\t\"memory_remove\",\n\t\"update_project_memory\",\n\t\"scratchpad\",\n\t\"todo\",\n\t\"todo_write\",\n\t\"graph_add\",\n]);\n\n/**\n * ¿Este nombre es de una tool NUESTRA cuyo nivel de confianza da esta política?\n *\n * Lo consulta el registro de extensiones para saber si `registerTool` está\n * suplantando una builtin. `bash` va aparte porque no está en ninguna de las dos\n * listas —lo desconocido ya es ejecución— pero suplantarlo importa igual: el\n * usuario tiene que ver que el `bash` que corre no es el nuestro.\n */\nexport function esNombreDeToolNuestra(tool: string): boolean {\n\treturn LECTURA.has(tool) || ESCRITURA.has(tool) || tool === \"bash\";\n}\n\n/**\n * El nivel de una herramienta. Lo que no está clasificado es ejecución.\n *\n * Falla cerrado a propósito: el coste de equivocarse hacia arriba es una\n * pregunta de más; hacia abajo, es una tool desconocida corriendo sola.\n */\nexport function nivelDe(tool: string): NivelTool {\n\t// Una builtin suplantada por una extensión NO hereda su nivel.\n\t//\n\t// Comprobado ejecutando: una extensión registra `read`, el loader la pone\n\t// encima de la nuestra y el modelo sigue creyendo que llama a la de Ada. Con\n\t// `LECTURA.has(\"read\")` por delante, ese `read` —que puede hacer lo que\n\t// quiera— se permitía siempre y en cualquier modo. Devolver \"ejecucion\" lo\n\t// devuelve al carril de lo desconocido, que es lo que es.\n\tif (suplantadaPor(tool)) return \"ejecucion\";\n\tif (LECTURA.has(tool)) return \"lectura\";\n\tif (ESCRITURA.has(tool)) return \"escritura\";\n\treturn \"ejecucion\";\n}\n\n/** Un directorio protegido aparece como segmento completo de la ruta. */\nfunction contieneSegmento(texto: string, segmento: string): boolean {\n\treturn texto.includes(`/${segmento}/`);\n}\n\n/**\n * ¿El texto nombra el directorio `dir` colgado de `base`, con barra final o sin\n * ella?\n *\n * La comprobación anterior solo miraba `base/dir/`, y por ahí se colaba justo el\n * caso peor. Comprobado ejecutando `decidir`:\n *\n *   rm -rf <agentDir>/vault/   -> denegada  ruta-protegida\n *   rm -rf <agentDir>/vault    -> PERMITIDA modo-yolo\n *\n * Es decir, el borrado entero del vault con un comando, porque el nombre de un\n * directorio no lleva barra al final cuando se lo pasas a `rm`. Se arregla aquí,\n * en la comprobación compartida, y no en cada llamada: la misma trampa valía\n * para el vault, para el libro y para cualquier directorio que se añada mañana.\n *\n * El caso sin barra se mide sobre el token y con el final exacto para no\n * llevarse por delante `vault-ejemplo` ni `sesiones/`. Se recorta la puntuación\n * de shell del final porque `rm -rf x/vault;` y `rm -rf x/vault)` son el mismo\n * comando con otro adorno.\n */\nfunction nombraDirectorio(texto: string, base: string, dir: string): boolean {\n\tif (texto.includes(`${base}${dir}/`)) return true;\n\treturn texto.split(/[\\s\"'`]+/).some((t) => t.replace(/[;,)&|>]+$/, \"\").endsWith(`${base}${dir}`));\n}\n\n/**\n * Deja la ruta en la forma con la que se compara.\n *\n * Sin esto la política era papel mojado, y se descubrió EJECUTANDO el producto:\n * el modelo escribe `~/.ada/agent/vault/…`, la tool expande la tilde por dentro\n * y abre el fichero, mientras que la política —que solo ve los argumentos\n * crudos— comparaba contra la ruta absoluta y no reconocía nada. El vault se\n * leyó entero con la política activada y todas las pruebas en verde, porque\n * todas usaban rutas absolutas.\n *\n * Se sustituye en TODO el texto y no solo al principio porque `bash` recibe una\n * línea entera, donde el `~` va detrás del comando.\n */\nfunction normalizar(texto: string, home: string): string {\n\treturn texto.replaceAll(\"$HOME/\", `${home}/`).replaceAll(\"~/\", `${home}/`);\n}\n\n/**\n * Si el texto nombra algo que no se puede tocar, devuelve por qué.\n *\n * Se mira el texto y no una \"ruta\" porque los argumentos no tienen un nombre\n * común (`path`, `file_path`, `command`…) y porque `bash` recibe una línea de\n * shell entera. Para `bash` esto es MEJOR ESFUERZO y hay que decirlo: quien\n * contiene de verdad un comando es el sandbox del sistema operativo, no esta\n * comprobación. Aquí se para lo evidente, que es lo que hace un agente\n * despistado; lo deliberado lo para el kernel.\n */\nfunction rutaProtegida(texto: string, agentDir: string, escribiendo: boolean): string | null {\n\tif (nombraDirectorio(texto, `${agentDir}/`, \"vault\")) return \"el vault cifrado\";\n\t// Generaliza lo de arriba a un vault de Ada en OTRA máquina (ver\n\t// `SEGMENTO_AGENTE_ADA`): mismo motivo, sin depender del `agentDir` local.\n\tif (nombraDirectorio(texto, SEGMENTO_AGENTE_ADA, \"vault\"))\n\t\treturn \"el vault cifrado (de este equipo o de un destino remoto)\";\n\n\t// El libro de auditoría y su índice.\n\t//\n\t// Agujero real, y el más grave que hemos tenido: la política protegía el\n\t// vault y el `auth.json` y dejaba al agente escribir y BORRAR libremente en\n\t// `<agentDir>/sesion/`, que es donde está el registro de lo que ha hecho. Es\n\t// decir, el sujeto de la auditoría tenía permiso de escritura sobre la\n\t// auditoría. Comprobado ejecutando `decidir`: `rm -rf <agentDir>/sesion/`\n\t// salía `permitida`.\n\t//\n\t// Denegado también para LEER, igual que el vault: el libro guarda hashes y\n\t// rutas de todo lo que ha pasado por la sesión, y no hay ninguna tarea\n\t// legítima del agente que necesite leerlo por el sistema de ficheros. Quien\n\t// tiene que verlo lo ve por `ada-cli audit show`, por `audit://` o por el\n\t// panel, que no pasan por esta política porque no son el agente.\n\tfor (const dir of [DIR_SESION, DIR_INDICE]) {\n\t\tif (nombraDirectorio(texto, `${agentDir}/`, dir)) return \"el libro de auditoría de la sesión\";\n\t\tif (nombraDirectorio(texto, SEGMENTO_AGENTE_ADA, dir)) {\n\t\t\treturn \"el libro de auditoría de la sesión (de este equipo o de un destino remoto)\";\n\t\t}\n\t}\n\n\t// Las credenciales de los proveedores, que viven EN CLARO en `auth.json`.\n\t//\n\t// Agujero real y propio: la primera versión de esta política protegía el\n\t// vault, las claves SSH, AWS y los `.env`, y dejaba abierto justo el fichero\n\t// donde están las claves con las que corre el agente. Se comprobó\n\t// ejecutando el producto y las leyó todas. Proteger la caja fuerte y dejar\n\t// las llaves encima no protege nada.\n\t//\n\t// Se compara con el nombre de fichero COMPLETO para no llevarse por delante\n\t// `auth.json.example`, `auth-storage.ts` ni `auth.md`, que son código y\n\t// documentación que el agente sí tiene que poder leer.\n\tfor (const parte of texto.split(/[\\s\"'`]+/)) {\n\t\tconst base = parte.slice(parte.lastIndexOf(\"/\") + 1);\n\t\tif (parte.includes(`${agentDir}/`) && base === \"auth.json\") return \"las credenciales de los proveedores\";\n\t\t// Igual, pero para el `auth.json` de un Ada corriendo en el DESTINO de\n\t\t// `--remoto`: no comparte `agentDir` con este equipo, así que el\n\t\t// segmento genérico es la única forma de reconocerlo.\n\t\tif (parte.includes(SEGMENTO_AGENTE_ADA) && base === \"auth.json\") {\n\t\t\treturn \"las credenciales de los proveedores (de este equipo o de un destino remoto)\";\n\t\t}\n\t\t// Y las de las otras herramientas: están en el mismo portátil y sirven\n\t\t// para lo mismo. Si el agente no ve las nuestras, no hay motivo para que\n\t\t// vea las de Claude Code, Codex, gh, Docker o kubectl.\n\t\tif (base === \".credentials.json\" || base === \".netrc\") return \"credenciales de otra herramienta\";\n\t\tif (contieneSegmento(parte, \".codex\") && base === \"auth.json\") return \"las credenciales de Codex\";\n\t\tif (contieneSegmento(parte, \"gh\") && base === \"hosts.yml\") return \"las credenciales de GitHub CLI\";\n\t\tif (contieneSegmento(parte, \".docker\") && base === \"config.json\") return \"las credenciales de Docker\";\n\t\tif (contieneSegmento(parte, \".kube\") && base === \"config\") return \"el acceso al clúster de Kubernetes\";\n\t}\n\n\tif (contieneSegmento(texto, \".ssh\")) return \"las claves SSH\";\n\tif (contieneSegmento(texto, \".gnupg\")) return \"las claves GPG\";\n\tif (contieneSegmento(texto, \".aws\")) return \"las credenciales de AWS\";\n\n\t// `.env` como nombre de fichero completo, no como prefijo: `.environment.ts`\n\t// es código normal y denegarlo dejaría medio proyecto ilegible sin que nadie\n\t// entendiera por qué.\n\tfor (const parte of texto.split(/[\\s\"'`]+/)) {\n\t\tconst base = parte.slice(parte.lastIndexOf(\"/\") + 1);\n\t\tif (base === \".env\" || base.startsWith(\".env.\")) return \"un fichero de entorno\";\n\t}\n\n\t// La configuración del agente se puede LEER pero no escribir. El\n\t// CVE-2026-25725 de Claude Code fue exactamente esto: código dentro del\n\t// sandbox creaba un settings.json e inyectaba hooks `SessionStart` que\n\t// corrían FUERA. Nuestro settings.json también ejecuta hooks.\n\tif (escribiendo && (texto.includes(`${agentDir}/settings.json`) || texto.includes(`${agentDir}/hooks`))) {\n\t\treturn \"la configuración del agente, que ejecuta hooks\";\n\t}\n\treturn null;\n}\n\n/** Todas las cadenas de los argumentos, a cualquier profundidad. */\nfunction cadenasDe(valor: unknown, acumulado: string[] = []): string[] {\n\tif (typeof valor === \"string\") acumulado.push(valor);\n\telse if (Array.isArray(valor)) for (const v of valor) cadenasDe(v, acumulado);\n\telse if (valor && typeof valor === \"object\") for (const v of Object.values(valor)) cadenasDe(v, acumulado);\n\treturn acumulado;\n}\n\nexport interface EntradaDecision {\n\ttool: string;\n\targs: Record<string, unknown>;\n\tmodo: ModoPermiso;\n\tagentDir: string;\n\t/**\n\t * Directorio del usuario, para resolver `~` y `$HOME` antes de comparar.\n\t *\n\t * Opcional y con `homedir()` por defecto para que el punto de llamada no\n\t * tenga que importarlo: `agent-session.ts` es de upstream y está en el tope\n\t * del presupuesto de fork, donde un `import` nuevo cuesta un hunk. Las\n\t * pruebas lo pasan siempre, así que siguen siendo deterministas.\n\t */\n\thome?: string;\n\t/** Tools que el usuario ha denegado explícitamente en su configuración. */\n\tdenegadas?: string[];\n\t/**\n\t * La política de máquina, para las pruebas.\n\t *\n\t * Opcional, y por defecto la del sistema. NO se lee de una variable de\n\t * entorno a propósito: una variable la pone el propio usuario, así que sería\n\t * la puerta trasera que anula toda la política de un `export`. Quien ya\n\t * ejecuta código en este proceso puede saltársela igual —la frontera es el\n\t * proceso, no esta función—, pero no debe haber un camino cómodo.\n\t */\n\tmaquina?: LecturaDePolitica;\n}\n\n/**\n * Lee `permissions.denied` de la configuración, tolerando que no exista.\n *\n * El bloque `permissions` es un `Record<string, unknown>` en settings, así que\n * lo que hay ahí no está tipado y puede ser cualquier cosa: se filtra a cadenas\n * en vez de confiar. Una entrada mal escrita tiene que perderse ella sola, no\n * tumbar la política entera y con ella la sesión.\n */\nexport function leerDenegadas(config: { permissions?: Record<string, unknown> } | undefined): string[] {\n\tconst lista = (config?.permissions as { denied?: unknown } | undefined)?.denied;\n\treturn Array.isArray(lista) ? lista.filter((x): x is string => typeof x === \"string\") : [];\n}\n\nexport function decidir({\n\ttool,\n\targs,\n\tmodo,\n\tagentDir,\n\thome,\n\tdenegadas,\n\tmaquina: maquinaDada,\n}: EntradaDecision): Decision {\n\tconst casa = home ?? homedir();\n\tconst nivel = nivelDe(tool);\n\n\t// 1. Rutas protegidas. Por delante de todo lo demás, incluido `yolo`.\n\t//    `ejecucion` cuenta como escritura: un `bash` puede reescribir el\n\t//    settings.json igual de bien que un `write`.\n\tconst escribiendo = nivel !== \"lectura\";\n\tfor (const cadena of cadenasDe(args)) {\n\t\tconst que = rutaProtegida(normalizar(cadena, casa), agentDir, escribiendo);\n\t\tif (que) {\n\t\t\treturn {\n\t\t\t\tveredicto: \"denegada\",\n\t\t\t\tpolitica: \"ruta-protegida\",\n\t\t\t\tmotivo: `Denegado: ${que}. No es configurable y no cambia con el modo de permisos. Si el usuario necesita ese dato, pídeselo.`,\n\t\t\t};\n\t\t}\n\t}\n\n\t// 2. Ficheros generados. Escribir en uno es trabajo que desaparece en la\n\t//    siguiente regeneración, y entre medias deja la fuente y el generado\n\t//    diciendo cosas distintas.\n\t//\n\t//    Va después de las rutas protegidas y antes del modo, porque no es\n\t//    negociable por comodidad — pero sí lo levanta el usuario diciéndolo, y\n\t//    el mensaje se lo explica al modelo para que lo pida en vez de insistir.\n\tif (escribiendo) {\n\t\tfor (const cadena of cadenasDe(args)) {\n\t\t\t// El filtro es \"se puede abrir\", no \"parece una ruta\".\n\t\t\t//\n\t\t\t// La versión anterior exigía una barra, y con eso `edit` sobre\n\t\t\t// `api.pb.go` —sin directorio— se colaba entera: la guarda estaba\n\t\t\t// puesta, las pruebas en verde, y el fichero generado se editó igual.\n\t\t\t// Solo salió ejecutando el CLI de verdad.\n\t\t\t//\n\t\t\t// Lo que sí se descarta antes de tocar el disco es lo que no puede ser\n\t\t\t// un nombre de fichero: contenido con saltos de línea (el `new_string`\n\t\t\t// de una edición) o cadenas absurdamente largas.\n\t\t\tif (cadena.length === 0 || cadena.length > 400 || cadena.includes(\"\\n\")) continue;\n\t\t\tlet contenido: string;\n\t\t\ttry {\n\t\t\t\tcontenido = readFileSync(normalizar(cadena, casa), \"utf-8\");\n\t\t\t} catch {\n\t\t\t\tcontinue; // no existe o no es un fichero: no hay nada que proteger\n\t\t\t}\n\t\t\tconst marca = marcaDeGenerado(contenido);\n\t\t\tif (marca) {\n\t\t\t\treturn { veredicto: \"denegada\", politica: \"fichero-generado\", motivo: motivoDeGenerado(cadena, marca) };\n\t\t\t}\n\t\t}\n\t}\n\n\t// 3. Lo que el usuario ha denegado. También sobrevive a `yolo`: si no,\n\t//    \"denegar\" significaría \"denegar hasta que al agente le convenga\".\n\tif (denegadas?.includes(tool)) {\n\t\treturn {\n\t\t\tveredicto: \"denegada\",\n\t\t\tpolitica: \"deny-de-usuario\",\n\t\t\tmotivo: `Denegado: el usuario ha desactivado \\`${tool}\\` en su configuración.`,\n\t\t};\n\t}\n\n\t// 4. La política de MÁQUINA, que el usuario no puede editar.\n\t//\n\t//    Va aquí y no en cada llamante porque `decidir()` la invocan siete\n\t//    sitios: un techo que haya que acordarse de poner en cada uno no es un\n\t//    techo. Y va antes del modo porque su único poder es recortarlo.\n\t//\n\t//    Los dos ámbitos que había —global y proyecto— son ficheros del propio\n\t//    usuario, así que la línea con la que el CISO prohíbe `yolo` la borraba\n\t//    él mismo con un editor de texto. Ver `politica-de-maquina.ts`.\n\tconst maquina = maquinaDada ?? politicaDeMaquina();\n\tif (maquina.politica?.denegadas?.includes(tool)) {\n\t\treturn {\n\t\t\tveredicto: \"denegada\",\n\t\t\tpolitica: \"deny-de-maquina\",\n\t\t\tmotivo:\n\t\t\t\t`Denegado: \\`${tool}\\` está desactivada por la política de este equipo` +\n\t\t\t\t(maquina.politica.motivo ? `: ${maquina.politica.motivo}` : \".\") +\n\t\t\t\t\" No la levanta el modo de permisos ni la configuración del usuario.\",\n\t\t};\n\t}\n\tconst efectivo = recortarModo(modo, maquina);\n\n\t// 5. El modo de la sesión, ya recortado.\n\tif (nivel === \"lectura\") return { veredicto: \"permitida\", politica: `modo-${efectivo}`, motivo: \"\" };\n\n\t// Que el recorte se NOMBRE en `politica` no es cosmético: ese campo va al\n\t// libro de sesión, así que un auditor puede ver que la decisión la tomó la\n\t// política del equipo y no la preferencia del usuario.\n\tconst sufijo = efectivo === modo ? \"\" : \"-por-politica-de-maquina\";\n\n\tswitch (efectivo) {\n\t\tcase \"plan\":\n\t\t\treturn {\n\t\t\t\tveredicto: \"denegada\",\n\t\t\t\tpolitica: `modo-plan${sufijo}`,\n\t\t\t\tmotivo: \"En modo plan no se actúa: propón el cambio en vez de aplicarlo.\",\n\t\t\t};\n\t\tcase \"manual\":\n\t\t\treturn { veredicto: \"preguntar\", politica: `modo-manual${sufijo}`, motivo: \"\" };\n\t\tcase \"auto\":\n\t\t\treturn nivel === \"escritura\"\n\t\t\t\t? { veredicto: \"permitida\", politica: `modo-auto${sufijo}`, motivo: \"\" }\n\t\t\t\t: { veredicto: \"preguntar\", politica: `modo-auto${sufijo}`, motivo: \"\" };\n\t\tdefault:\n\t\t\treturn { veredicto: \"permitida\", politica: `modo-yolo${sufijo}`, motivo: \"\" };\n\t}\n}\n"]}