@anchrd/intel-ui 0.12.0 → 0.13.0

package/src/i18n/es.json

@@ -0,0 +1,402 @@
+{
+  "$locale": "es-ES",
+  "app.name": "Intel",
+  "nav.primary": "Navegación principal",
+  "nav.nodes": "Conocimiento",
+  "nav.flows": "Flujos",
+  "nav.tools": "Herramientas",
+  "shell.toggleSidebar": "Plegar o desplegar la barra lateral",
+  "shell.resizeSidebar": "Ancho de la barra lateral",
+  "shell.signedInUser": "Persona conectada",
+  "shell.userUnavailable": "Cuenta no disponible",
+  "shell.userMenu": "Cuenta y herramientas de {name}",
+  "search.open": "Buscar",
+  "search.title": "Buscar en Intel",
+  "search.description": "Encuentra documentos, flujos y herramientas que puedes ver.",
+  "search.placeholder": "Buscar documentos, flujos y herramientas",
+  "search.filter": "Filtrar por tipo",
+  "search.all": "Todo",
+  "search.kind.node": "Conocimiento",
+  "search.kind.flow": "Flujos",
+  "search.kind.tool": "Herramientas",
+  "search.hint": "Escribe para buscar.",
+  "search.searching": "Buscando…",
+  "search.empty": "No se ha encontrado nada para «{query}».",
+  "search.failed": "La búsqueda no se ha podido completar.",
+  "tree.label": "Conocimiento y flujos",
+  "tree.contents": "Dentro de {title}",
+  "tree.calls": "Flujos a los que llama {title}",
+  "tree.empty": "Aquí todavía no hay nada.",
+  "tree.failed": "Esta parte del árbol no se ha podido cargar.",
+  "tree.expand": "Mostrar lo que hay dentro de {title}",
+  "tree.collapse": "Ocultar lo que hay dentro de {title}",
+  "tree.expandCalls": "Mostrar los flujos a los que llama {title}",
+  "tree.collapseCalls": "Ocultar los flujos a los que llama {title}",
+  "tree.add": "Añadir a {title}",
+  "tree.addRoot": "Añadir en el nivel superior",
+  "tree.new.folder": "Carpeta nueva",
+  "tree.new.document": "Documento nuevo",
+  "tree.new.table": "Tabla nueva",
+  "tree.new.upload": "Subir un archivo",
+  "tree.new.flow": "Flujo nuevo",
+  "tree.new.agent": "Agente nuevo",
+  "tree.upload": "Archivo que subir",
+  "tree.table.columns": "Columnas",
+  "tree.table.columnsHint": "Separa los nombres de las columnas con comas. Son la cabecera, y toda fila añadida después tiene que encajar con ella.",
+  "tree.createFailed": "No se ha podido crear. Comprueba tu acceso e inténtalo de nuevo.",
+  "tree.uploadFailed": "El archivo no se ha podido subir. Comprueba el límite de 15 MB e inténtalo de nuevo.",
+  "tree.kind.folder": "Carpeta",
+  "tree.kind.document": "Documento",
+  "tree.kind.attachment": "Archivo",
+  "tree.kind.table": "Tabla",
+  "tree.kind.agent": "Agente",
+  "tree.kind.flow": "Flujo",
+  "tree.move.action": "Mover a…",
+  "tree.move.title": "Mover {title}",
+  "tree.move.root": "Nivel superior",
+  "tree.move.dropRoot": "Suelta aquí para mover al nivel superior",
+  "tree.move.pick": "Elige la carpeta a la que moverlo.",
+  "tree.move.up": "Volver a la carpeta de arriba",
+  "tree.move.open": "Abrir {title}",
+  "tree.move.noFolders": "Aquí no hay ninguna carpeta a la que moverlo.",
+  "tree.move.here": "Mover dentro de {title}",
+  "tree.move.alreadyThere": "Ya está archivado aquí.",
+  "tree.move.destination": "Sitio nuevo: {title}",
+  "tree.move.sharingWarning": "El acceso sigue a la carpeta. Después de moverlo, todo el que llegue a {title} llegará a esta entrada, y quien solo llegaba a ella por su carpeta anterior la perderá. No se avisa a nadie.",
+  "tree.move.elsewhere": "Elegir otra carpeta",
+  "tree.move.confirm": "Mover",
+  "tree.move.failed.forbidden": "No se ha movido: no puedes escribir en esa carpeta. Pide acceso de escritura allí.",
+  "tree.move.failed.notFolder": "No se ha movido: solo una carpeta puede contener otras entradas.",
+  "tree.move.failed.cycle": "No se ha movido: una carpeta no puede ir dentro de sí misma ni dentro de nada que contenga.",
+  "tree.move.failed.conflict": "No se ha movido: otra persona ha cambiado esta entrada antes. El árbol se ha recargado — míralo otra vez y muévelo entonces.",
+  "tree.move.failed.gone": "No se ha movido: esa carpeta ya no existe.",
+  "tree.move.failed.other": "No se ha podido mover. Comprueba tu acceso e inténtalo de nuevo.",
+  "resource.menu": "Más acciones para {title}",
+  "resource.rename": "Cambiar el nombre",
+  "resource.renameTitle": "Cambiar el nombre de {title}",
+  "resource.archive": "Archivar",
+  "resource.export": "Descargar como zip",
+  "tree.new.importZip": "Importar un paquete zip",
+  "tree.new.importFolder": "Importar una carpeta",
+  "tree.importFailed": "La importación no se ha aplicado. No se ha creado nada — comprueba el paquete e inténtalo de nuevo.",
+  "resource.exportFailed": "La exportación no se ha podido descargar. Comprueba tu acceso e inténtalo de nuevo.",
+  "archive.title": "Archivo",
+  "archive.description": "Todo lo que has archivado, lo más reciente primero. Al restaurar, una entrada vuelve al sitio donde estaba.",
+  "archive.restore": "Restaurar {title}",
+  "archive.restoreAction": "Restaurar",
+  "archive.empty": "No hay nada archivado.",
+  "archive.failed": "El archivo no se ha podido leer. Comprueba tu acceso e inténtalo de nuevo.",
+  "archive.restoreFailed": "No se ha restaurado. Puede que otra persona lo haya cambiado — recarga e inténtalo de nuevo.",
+  "archive.archivedAt": "Archivado {when}",
+  "resource.conflict": "No se ha cambiado: otra persona ha cambiado esta entrada antes. Recárgala e inténtalo de nuevo.",
+  "resource.forbidden": "No se ha cambiado: no puedes cambiar esta entrada.",
+  "resource.failed": "El cambio no se ha guardado. Carga la versión más reciente e inténtalo de nuevo.",
+  "node.empty": "Todavía no se ha añadido nada.",
+  "node.download": "Descargar el archivo",
+  "node.attachmentHelp": "El archivo canónico se guarda en privado en Intel. Su proyección legible por la IA se indexa por separado.",
+  "node.table.summary": "{rows} filas, {columns} columnas",
+  "node.table.download": "Descargar CSV",
+  "node.table.empty": "Todavía no hay filas. Las filas las añaden los flujos y los agentes.",
+  "node.table.undefined": "Esta tabla todavía no tiene columnas.",
+  "node.select": "Elige un documento o una carpeta para trabajar con ello.",
+  "node.folderEmpty": "En esta carpeta todavía no hay nada. Crea algo con el más de la barra lateral.",
+  "node.folderFailed": "Esta carpeta no se ha podido leer.",
+  "node.changed": "Cambiado",
+  "node.rowActions": "Acciones",
+  "node.kind.folder": "Carpeta",
+  "node.kind.document": "Documento",
+  "node.kind.attachment": "Subida",
+  "node.kind.table": "Tabla",
+  "node.kind.agent": "Agente",
+  "node.kind.flow": "Flujo",
+  "node.share": "Compartir",
+  "node.shareAction": "Conceder acceso",
+  "node.email": "Dirección de correo",
+  "node.verbs": "Qué permite este acceso",
+  "node.verb.read": "Leer",
+  "node.verb.write": "Escribir",
+  "node.verb.execute": "Ejecutar",
+  "node.verb.share": "Compartir",
+  "node.verbHint.read": "Ver todo lo que hay aquí dentro",
+  "node.verbHint.write": "Cambiar y añadir cosas",
+  "node.verbHint.execute": "Iniciar los flujos que hay aquí dentro",
+  "node.verbHint.execute.agent": "Usar este agente — su chat, sus horarios y su dirección MCP",
+  "node.verbHint.share": "Dar acceso a otras personas",
+  "node.organization": "Todas las personas de la organización",
+  "node.revokeShare": "Retirar el acceso",
+  "node.noGrants": "Fuera de quien lo posee, todavía no tiene acceso nadie.",
+  "node.shareFailed": "El acceso no se ha cambiado. Comprueba tu permiso e inténtalo de nuevo.",
+  "node.shareUnreadable": "Los flujos de esta carpeta leen documentos que este acceso no cubre: {titles}.",
+  "node.shareUnreadableMore": "{count} más también quedan fuera de alcance, y no puedes verlos.",
+  "node.shareUnreadableHidden": "{count} documentos que leen los flujos de esta carpeta quedan fuera de alcance con este acceso. No puedes verlos.",
+  "node.shareUnreadableHint": "No se bloquea nada. Una ejecución de esos flujos simplemente se detendrá en ese paso para esa persona.",
+  "node.versions": "Historial de versiones",
+  "node.version": "Versión {sequence}",
+  "view.showGraph": "Mostrar este nivel como grafo",
+  "view.showEditor": "Volver al editor",
+  "view.showRuns": "Mostrar las ejecuciones de este flujo",
+  "view.graph": "Grafo de relaciones",
+  "view.graphTruncated": "{omitted} más quedan fuera — esta vista dibuja como mucho {limit}.",
+  "view.graphEmpty": "Aquí no hay nada que puedas ver.",
+  "view.graphFailed": "El grafo no se ha podido cargar.",
+  "node.graphZoomIn": "Acercar",
+  "node.graphZoomOut": "Alejar",
+  "node.graphReset": "Ajustar el grafo",
+  "node.operationFailed": "El cambio no se ha guardado. Carga la versión más reciente e inténtalo de nuevo.",
+  "node.loadFailed": "Este elemento no se ha podido cargar. Comprueba tu acceso e inténtalo de nuevo.",
+  "node.downloadFailed": "El adjunto no se ha podido descargar. Comprueba tu acceso e inténtalo de nuevo.",
+  "node.links": "Enlaces y retroenlaces",
+  "node.noLinks": "Todavía no hay relaciones explícitas.",
+  "node.linksHelp": "Las relaciones se escriben en el texto. Enlaza un documento desde el editor con el comando /; esta lista muestra el resultado y quién apunta aquí.",
+  "node.linkOutgoing": "Este documento enlaza con él",
+  "node.linkIncoming": "Enlaza con este documento",
+  "node.link.insert": "Enlazar un documento",
+  "node.link.group": "Documentos",
+  "node.link.search": "Buscar entre los documentos que puedes ver",
+  "node.link.noMatches": "Ningún documento tuyo coincide.",
+  "node.link.unresolved": "Documento no disponible",
+  "node.saveConflict": "Este documento ha cambiado en otro sitio. Recárgalo antes de volver a guardar.",
+  "node.saveError": "Este documento no se ha podido guardar. Recarga e inténtalo de nuevo.",
+  "tools.signingIn": "Iniciando tu sesión en el portal de la empresa…",
+  "tools.noAccess": "Sin acceso al portal de la empresa",
+  "tools.noAccessHelp": "Tu cuenta de Intel no llega al portal MCP de la empresa, así que aquí no hay nada que mostrar. Quién puede usar qué servidor lo decide la administración en el portal; pídeles que te incluyan.",
+  "tools.empty": "No tienes herramientas disponibles",
+  "tools.emptyHelp": "El portal ha respondido, y no ofrece ninguna herramienta a tu cuenta. Qué servidores existen y quién llega a ellos lo decide la administración en el portal.",
+  "tools.unreachable": "Portal no accesible",
+  "tools.unreachableHelp": "El portal MCP de la empresa no ha respondido, así que Intel no puede decir qué herramientas tienes. Aquí no se guarda nada; inténtalo otra vez cuando el portal responda.",
+  "tools.connectExpired": "El inicio de sesión en el portal ha tardado demasiado",
+  "tools.connectExpiredHelp": "La conexión con el portal MCP de la empresa tiene que completarse en unos minutos, y esta se ha agotado mientras la pantalla de autorización estaba abierta. No ha fallado nada ni se ha denegado nada — vuelve a empezar y confirma los servidores cuando aparezca la pantalla.",
+  "tools.connectRetry": "Empezar de nuevo",
+  "tools.connectFailed": "El inicio de sesión en el portal ha fallado",
+  "tools.connectFailedHelp": "El inicio de sesión en el portal MCP de la empresa se ha interrumpido antes de poder responderse. Es un fallo técnico, no una decisión sobre tu acceso — recarga para intentarlo otra vez y avisa a la administración si persiste.",
+  "tools.origin": "Origen",
+  "tools.originUnlisted": "No procede de un servidor listado",
+  "tools.originUnlistedHelp": "La lista de servidores del portal no nombra ningún servidor para estas. Aquí están sus propias herramientas de gestión — el portal no se lista a sí mismo — y también todo lo que venga de un servidor que la lista no mencionó.",
+  "tools.ungrouped": "Sin ordenar por servidor",
+  "tools.ungroupedHelp": "El portal MCP de la empresa no ha respondido de qué servidores vienen estas herramientas, así que Intel no puede decir qué herramienta pertenece a dónde. Abajo está todo lo que puedes alcanzar; solo falta la agrupación.",
+  "tools.inputSchema": "Esquema de entrada",
+  "tools.outputSchema": "Esquema del resultado",
+  "tools.destructiveShort": "Destructiva",
+  "tools.destructiveCount": "{count} destructivas",
+  "tools.toolCount": "{count} herramientas",
+  "tools.toolCountOne": "1 herramienta",
+  "tools.liveNote": "Esta lista es una consulta en vivo con tu propio acceso al portal. Intel no guarda ni las herramientas ni quién puede usarlas; ambas cosas las decide el portal.",
+  "tools.arguments": "Argumentos",
+  "tools.invalidJson": "Los argumentos tienen que ser un objeto JSON entre llaves; una lista o un valor suelto no sirven.",
+  "flows.select": "Elige un flujo o crea uno para abrir el editor visual.",
+  "flows.inspect": "Elige un paso para editar su configuración.",
+  "flows.publish": "Publicar",
+  "flows.publishNothing": "Nada nuevo que publicar",
+  "flows.publishNeeded": "Publicar — hasta entonces no puede empezar ninguna ejecución",
+  "flows.validate": "Comprobar si se ejecutaría",
+  "flows.validateReady": "Este flujo empezaría ahora mismo.",
+  "flows.validateWhen": "Comprobado {when}. El acceso a las herramientas se pide cada vez con tu propio token, así que esta respuesta es una instantánea.",
+  "flows.problem.flow_execute_forbidden": "No puedes ejecutar este flujo",
+  "flows.problem.flow_not_published": "El flujo no está publicado",
+  "flows.problem.flow_graph_invalid": "El grafo no se puede ejecutar",
+  "flows.problem.flow_tools_unavailable": "Una herramienta está fuera de alcance",
+  "flows.problem.flow_node_forbidden": "Material que lee un paso está fuera de alcance",
+  "flows.problem.flow_subflow_unavailable": "Un flujo llamado no está disponible",
+  "flows.problem.flow_subflow_not_published": "Un flujo llamado no está publicado",
+  "flows.addNode": "Añadir un paso",
+  "flows.closePalette": "Cerrar la barra de pasos",
+  "flows.nodePalette": "Tipos de paso",
+  "flows.node.trigger": "Inicio",
+  "flows.startExists": "Un flujo tiene exactamente un inicio, y este ya lo tiene.",
+  "flows.node.instruction": "Instrucción",
+  "flows.node.folder": "Carpeta",
+  "flows.node.document": "Documento",
+  "flows.node.upload": "Subida",
+  "flows.node.table": "Tabla",
+  "flows.node.tool": "Herramienta",
+  "flows.node.condition": "Condición",
+  "flows.node.subflow": "Flujo",
+  "flows.node.output": "Fin",
+  "flows.instruction": "Instrucción para la IA o la persona",
+  "flows.instructionHint": "Las condiciones, comprobaciones y bifurcaciones se pueden describir aquí con palabras. No hace falta un paso propio para cada decisión pequeña.",
+  "flows.linkEmpty": "Todavía no se ha elegido nada",
+  "picker.search": "Buscar por nombre",
+  "picker.top": "Todas las carpetas",
+  "picker.open": "Abrir {title}",
+  "picker.nothing": "Aquí no hay nada",
+  "flows.layer.marker": "Marcas",
+  "flows.layer.step": "Pasos",
+  "flows.layer.link": "Conexiones",
+  "flows.subflowTarget": "Flujo al que llamar",
+  "flows.selectSubflow": "Elige un flujo al que llamar",
+  "flows.subflowRule": "Un flujo puede llamar a un flujo de su propia carpeta o por debajo de ella, o a uno de una carpeta que todo el mundo puede ejecutar. Al publicar se nombra el motivo si no puede.",
+  "flows.subflowVersion": "Versión a la que llamar",
+  "flows.subflowVersion.latest": "La más reciente — se congela al publicar este flujo",
+  "flows.subflowVersion.follows": "Siempre la más reciente — esta llamada va con ella",
+  "flows.subflowVersion.pinned": "Versión congelada",
+  "flows.subflowVersionHint.latest": "Al publicar, esto se sustituye por la versión que el flujo llamado tenga publicada entonces, así que un cambio posterior allí deja este flujo en paz.",
+  "flows.subflowVersionHint.follows": "Esta llamada toma lo que el flujo llamado tenga publicado en el momento de ejecutarse. Un cambio allí cambia también este flujo.",
+  "flows.subflowVersionHint.pinned": "Esta llamada sigue ejecutando la versión a la que se congeló. Vuelve a ponerla en «la más reciente» para recoger la próxima publicación del flujo llamado.",
+  "flows.subflowBadge.follows": "va con ella",
+  "flows.subflowBadge.pinned": "congelada",
+  "flows.publishPreview": "Antes de publicar",
+  "flows.publishPreviewIntro": "Al publicar se congela cada llamada marcada abajo a la versión que nombra. Una llamada puesta en «siempre la más reciente» se queda como está.",
+  "flows.publishPreviewEmpty": "Este flujo no llama a ningún otro flujo, así que al publicar no se congela nada.",
+  "flows.publishPreviewFreeze": "se congela a la versión {sequence}",
+  "flows.publishPreviewPinned": "ya congelada a la versión {sequence}",
+  "flows.publishPreviewFollows": "va con el flujo llamado",
+  "flows.publishPreviewUnavailable": "El flujo llamado todavía no ha publicado nada, así que esto no se puede congelar.",
+  "flows.publishConfirm": "Publicar",
+  "flows.publishFailed": "La publicación ha fallado. Carga la versión más reciente e inténtalo de nuevo.",
+  "flows.tool": "Herramienta MCP",
+  "flows.selectTool": "Elige una herramienta descubierta",
+  "flows.operationFailed": "La operación del flujo ha fallado. Carga la versión más reciente e inténtalo de nuevo.",
+  "flows.needs": "Qué necesita este flujo",
+  "flows.needsHint": "Leído del grafo. Si una persona concreta llega a algo de esto se decide cuando lo ejecuta.",
+  "flows.needsNodes": "Documentos",
+  "flows.needsTools": "Herramientas",
+  "flows.needsHidden": "{count} más que no puedes ver",
+  "flows.needsEmpty": "Este flujo no lee ningún documento ni llama a ninguna herramienta.",
+  "flows.needsFailed": "Lo que necesita este flujo no se ha podido cargar.",
+  "runs.title": "Ejecuciones",
+  "runs.onlyFailed": "Solo las ejecuciones fallidas",
+  "runs.empty": "Este flujo todavía no se ha ejecutado.",
+  "runs.emptyFailed": "Ninguna ejecución de este flujo ha fallado.",
+  "runs.more": "Mostrar ejecuciones anteriores",
+  "runs.stillRunning": "todavía en marcha",
+  "runs.failedAt": "Ha fallado en {step}:",
+  "runs.failedToLoad": "Las ejecuciones de este flujo no se han podido cargar.",
+  "runs.stepsFailedToLoad": "Los pasos de esta ejecución no se han podido cargar.",
+  "runs.stepsEmpty": "Esta ejecución todavía no ha completado ningún paso.",
+  "runs.stepsTitle": "Pasos",
+  "runs.durationMs": "{value} ms",
+  "runs.durationSeconds": "{value} s",
+  "runs.durationMinutes": "{value} min",
+  "runs.status.queued": "En cola",
+  "runs.status.running": "En marcha",
+  "runs.status.waiting": "Esperando",
+  "runs.status.completed": "Completada",
+  "runs.status.failed": "Fallida",
+  "runs.status.cancelled": "Cancelada",
+  "runs.trigger.manual": "iniciada a mano",
+  "runs.trigger.subflow": "llamada por otro flujo",
+  "runs.outcome.completed": "hecha",
+  "runs.outcome.failed": "fallida",
+  "agent.tabs": "Vistas del agente",
+  "agent.tab.profile": "Perfil",
+  "agent.tab.chat": "Chat",
+  "agent.tab.calendar": "Calendario",
+  "agent.tab.log": "Registro",
+  "agent.statusRunning": "En marcha",
+  "agent.statusIdle": "Inactivo",
+  "agent.statusPaused": "En pausa",
+  "agent.statusUnknown": "Entorno de ejecución no accesible",
+  "agent.nextRun": "próxima ejecución {when} ({zone})",
+  "agent.noNextRun": "sin ejecución programada",
+  "agent.pausedNoRuns": "no se dispara ningún horario, no se acepta ninguna tarea ni ningún correo; el chat sigue respondiendo",
+  "agent.pause": "Pausar",
+  "agent.resume": "Reanudar",
+  "agent.runNow": "Ejecutar ahora",
+  "agent.runNowNoTarget": "Este agente no tiene horario, así que no hay nada que ejecutar.",
+  "agent.runNowPaused": "Reanuda el agente antes de ejecutarlo.",
+  "agent.actionFailed": "Eso no ha funcionado. Inténtalo de nuevo.",
+  "agent.keyMissing": "Este agente no tiene clave de aplicación, así que no puede empezar ninguna ejecución. Sustituye su clave en «Identidad», dentro del perfil.",
+  "agent.notPermitted": "Puedes leer este agente, pero no manejarlo. Manejar un agente necesita el permiso «ejecutar agentes».",
+  "agent.noRuntime": "Esta instalación no tiene entorno de ejecución de agentes, así que este agente no puede chatear ni ejecutarse aquí. Su definición se conserva y vuelve a funcionar en una instalación que sí lo tenga.",
+  "agent.loadFailed": "Este agente no se ha podido cargar. Comprueba tu acceso e inténtalo de nuevo.",
+  "agent.saveFailed": "El cambio no se ha guardado. Puede que otra persona haya cambiado este agente antes — recarga e inténtalo de nuevo.",
+  "agent.noDefinition": "Este agente todavía no tiene definición, así que aquí no hay nada que cambiar.",
+  "agent.identity": "Identidad",
+  "agent.identityHint": "La aplicación de Gate con la que actúa este agente. Sus permisos en el árbol deciden qué puede leer y escribir una ejecución, y su clave vive cifrada en el entorno de ejecución de agentes — nunca aquí y nunca en la definición.",
+  "agent.principal": "Aplicación de Gate",
+  "agent.principalNone": "Ninguna",
+  "agent.principalNoneHint": "Este agente no tiene aplicación de Gate, así que no hay ninguna clave que sustituir. Los agentes creados antes de esta función, importados o restaurados desde un paquete reciben una en Gate.",
+  "agent.rotateKey": "Sustituir la clave",
+  "agent.rotateKeyConfirm": "Se emite una clave nueva y se entrega al entorno de ejecución de agentes. La clave anterior deja de funcionar de inmediato, y aquí nunca se muestra ninguna clave.",
+  "agent.rotateKeyDone": "La clave se ha sustituido. El agente funciona con la nueva a partir de su próxima ejecución.",
+  "agent.rotateKeyFailed": "La clave no se ha sustituido. Inténtalo otra vez — e insiste hasta que salga bien: si Gate ya ha emitido la clave nueva, este agente no puede ejecutarse hasta que el entorno de ejecución la tenga.",
+  "agent.contact": "Contacto",
+  "agent.contactHint": "Cómo se llega a este agente. El chat integrado forma parte del entorno de ejecución y está siempre ahí.",
+  "agent.contactChat": "Chat integrado",
+  "agent.contactChatBuiltIn": "Integrado, siempre ahí",
+  "agent.contactMcp": "Dirección MCP",
+  "agent.copy": "Copiar",
+  "agent.copied": "Copiado",
+  "agent.contactAdd": "Añadir un contacto",
+  "agent.contactAddReason": "Una dirección de correo pertenece a la instalación, no a la definición del agente, así que se configura donde está desplegado el entorno de ejecución.",
+  "agent.knows": "Lo que sabe",
+  "agent.knowsHint": "Las carpetas que lee este agente y para qué cuenta cada una. Un mensaje de sistema lo instruye, el contexto semántico se busca, en la memoria se escribe de vuelta.",
+  "agent.addReference": "Añadir una carpeta",
+  "agent.removeReferenceOf": "Dejar de leer {title}",
+  "agent.pickFolder": "Carpeta que leer",
+  "agent.roleFor": "Para qué cuenta {title}",
+  "agent.role.system-message": "Mensaje de sistema",
+  "agent.role.semantic-context": "Contexto semántico",
+  "agent.role.memory": "Memoria",
+  "agent.unknownEntry": "No disponible para ti",
+  "agent.tools": "Herramientas",
+  "agent.toolsHint": "Los servidores MCP que le das a este agente, de entre los que tú mismo alcanzas. Intel guarda la elección, nunca el permiso — las herramientas que hay detrás de un servidor se leen en vivo con tu acceso al portal cada vez que el agente se ejecuta.",
+  "agent.addTool": "Añadir una herramienta",
+  "agent.removeToolServerOf": "Quitarle {name} a este agente",
+  "agent.toolServerUnavailable": "Ya no alcanzas este servidor",
+  "agent.toolsDelegationNotice": "Quien pueda ejecutar este agente actúa sobre tu conexión.",
+  "agent.toolsNotConnected": "Todavía no has iniciado sesión en el portal de la empresa, así que no hay nada que ceder. Abre «Herramientas» para conectarte.",
+  "agent.toolsNoneLeft": "Todos los servidores que alcanzas ya están dados a este agente.",
+  "agent.schedule": "Horario",
+  "agent.scheduleHint": "Cuándo actúa este agente por su cuenta y qué ejecuta. Cada horario conserva la zona horaria con la que se creó, así que significa la misma hora para todo el que lo lea.",
+  "agent.scheduleEmpty": "Este agente solo se ejecuta cuando se le pide.",
+  "agent.addSchedule": "Añadir un horario",
+  "agent.removeSchedule": "Quitar este horario",
+  "agent.scheduleTarget": "Qué ejecutar",
+  "agent.cron": "Cuándo",
+  "agent.scheduleTimezone": "Zona horaria",
+  "agent.scheduleTimezoneHint": "En qué se lee la expresión de arriba. Se propone a partir de tu propia preferencia y se guarda con el horario — si cambias tu preferencia más adelante, este se queda como está.",
+  "agent.cronHint": "Cinco campos: minuto, hora, día del mes, mes, día de la semana. «0 8 * * *» es todos los días a las 08:00 en la zona horaria de abajo.",
+  "agent.model": "Modelo",
+  "agent.modelHint": "Qué modelo piensa. El entorno de ejecución recoge un cambio en menos de un minuto.",
+  "agent.modelFigures": "{context} de contexto · {input} $ de entrada / {output} $ de salida por cada millón de tokens",
+  "agent.calendar": "Próximas ejecuciones",
+  "agent.calendarZones": "Cada hora se muestra en la zona horaria de su propio horario, porque es cuando se ejecuta el agente.",
+  "agent.calendarUnreadable": "Ninguno de los horarios de este agente se puede leer como expresión cron, así que no hay nada planificado.",
+  "agent.log": "Ejecuciones",
+  "agent.logEmpty": "Este agente todavía no se ha ejecutado.",
+  "agent.logFailed": "Las ejecuciones no se han podido leer. Puede que el entorno de ejecución de agentes no sea accesible desde aquí.",
+  "agent.runFailed": "Esta ejecución no se ha podido leer.",
+  "agent.runLog": "Lo que ha hecho esta ejecución",
+  "agent.runLogEmpty": "Esta ejecución no ha registrado nada.",
+  "agent.steps": "{count} pasos",
+  "agent.trigger.chat": "desde el chat",
+  "agent.trigger.schedule": "por horario",
+  "agent.trigger.mail": "desde un correo",
+  "agent.trigger.task": "pedido por MCP",
+  "agent.trigger.manual": "iniciada a mano",
+  "agent.chatEmpty": "Escríbele a este agente. Responde con lo que sabe y con las herramientas que puede alcanzar.",
+  "agent.chatInput": "Mensaje para este agente",
+  "agent.chatPlaceholder": "Pregunta algo…",
+  "agent.chatSend": "Enviar",
+  "agent.chatScrollDown": "Saltar al mensaje más reciente",
+  "settings.title": "Preferencias",
+  "settings.description": "Idioma, apariencia y zona horaria. Las tres se aplican de inmediato y se recuerdan en este dispositivo.",
+  "settings.language": "Idioma",
+  "settings.appearance": "Apariencia",
+  "settings.appearance.system": "Seguir al sistema",
+  "settings.appearance.light": "Claro",
+  "settings.appearance.dark": "Oscuro",
+  "settings.timezone": "Zona horaria",
+  "settings.timezoneHint": "Se usa para leer las horas y se propone cuando le das un horario a un agente. Un horario conserva la zona con la que se creó, así que viajar no mueve las ejecuciones que ya has fijado.",
+  "auth.signOut": "Cerrar sesión",
+  "auth.signOutFailed": "El cierre de sesión ha fallado. Comprueba tu conexión e inténtalo de nuevo.",
+  "signIn.refusedTitle": "Sesión iniciada, pero no aceptada",
+  "signIn.refusedBody": "Gate ha iniciado tu sesión, y esta instalación no ha aceptado la credencial. No se te ha devuelto al inicio de sesión, porque ahí es donde empieza el bucle.",
+  "signIn.refusedLikely": "Lo más habitual es que la sesión caducara entre los dos pasos, o que la credencial se emitiera para otra instalación. Recargar merece un intento; después de eso, tiene que mirarlo quien gestiona esta instalación.",
+  "signIn.refusedRetry": "Intentarlo de nuevo",
+  "common.title": "Título",
+  "common.create": "Crear",
+  "common.save": "Guardar",
+  "common.saving": "Guardando…",
+  "common.saved": "Guardado",
+  "common.saveDirty": "Guardar los cambios sin guardar",
+  "common.unsavedTitle": "Cambios sin guardar",
+  "common.unsavedBody": "Esto tiene cambios que no se han guardado. Si sales ahora, se descartan.",
+  "common.unsavedStay": "Quedarse y guardar",
+  "common.unsavedLeave": "Salir sin guardar",
+  "common.loading": "Cargando…",
+  "common.retry": "Intentarlo de nuevo",
+  "common.close": "Cerrar",
+  "common.unavailable": "Intel no está disponible en este momento."
+}

package/src/i18n/i18n-context.tsx

@@ -0,0 +1,65 @@
+import { createContext, type ReactNode, useContext, useEffect, useMemo, useState } from "react";
+import { createI18n } from "./i18n.ts";
+import type { I18n, LanguageChoice, Languages } from "./i18n.types.ts";
+
+// The React seam of the i18n. Until #227 the instance travelled in the router context, which is
+// static — there was no way to switch language without reloading the page. It is a context now, for
+// the same reason the data provider is one: it is a dependency, not a module singleton. Unlike the
+// data provider it has a sensible default — the English instance — so a component rendered without
+// a provider (component tests) does not throw but simply speaks English.
+const defaultI18n = createI18n();
+
+const I18nContext = createContext<I18n>(defaultI18n);
+
+// The choice between the available languages. `null` without a provider — not an empty list: the
+// settings dialog asks precisely whether there is anything to switch at all.
+const LanguageContext = createContext<LanguageChoice | null>(null);
+
+interface I18nProviderProps {
+  languages: Languages;
+  children: ReactNode;
+}
+
+// The provider holds the active language — the only state the i18n has at runtime. It is client
+// state (a preference), so it lives locally; remembering it is the job of createLanguages.
+export function I18nProvider({ languages, children }: I18nProviderProps) {
+  const [current, setCurrent] = useState(languages.initial);
+  const i18n = useMemo(() => languages.i18n(current), [languages, current]);
+
+  // The root document reports the same language as the active catalog — at start AND after every
+  // switch. Otherwise a screen reader reads Spanish text with English pronunciation rules, and the
+  // browser offers a translation that is none. index.html only carries the static default.
+  useEffect(() => {
+    document.documentElement.lang = i18n.locale;
+  }, [i18n.locale]);
+
+  const choice = useMemo<LanguageChoice>(
+    () => ({
+      codes: languages.codes,
+      current,
+      select: (code) => {
+        languages.remember(code);
+        setCurrent(code);
+      },
+    }),
+    [languages, current],
+  );
+
+  return (
+    <I18nContext value={i18n}>
+      <LanguageContext value={choice}>{children}</LanguageContext>
+    </I18nContext>
+  );
+}
+
+// The whole instance, not just `t`: intel's screens hand `i18n` down to presentational children as a
+// prop (ToolRows, GraphNotice, RelationGraphView …), and those need the object. A `useT()` would
+// force either drilling `t` separately or turning every one of those into a hook consumer — a
+// different refactor, and one that buys nothing.
+export function useI18n(): I18n {
+  return useContext(I18nContext);
+}
+
+export function useLanguage(): LanguageChoice | null {
+  return useContext(LanguageContext);
+}

package/src/i18n/i18n-languages/i18n-languages.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import custom from "../custom.json";
+import de from "../de.json";
+import en from "../en.json";
+import es from "../es.json";
+import { CatalogSchema, createI18n } from "../i18n.ts";
+import type { Catalog, Languages, LanguagesDeps } from "../i18n.types.ts";
+
+// The language choice: which languages exist is the built-in set plus whatever `intel build` wrote
+// into custom.json; which one runs is the reader's decision. Kept apart from createI18n, because the
+// lookup needs to know none of this — it receives a catalog and reads from it.
+
+// localStorage is right here and ONLY here: the language choice is a UI preference, not a mirror of
+// server data (TanStack Query holds that) and not a secret. That is exactly why it survives a
+// reload.
+const STORE_KEY = "intel.language";
+
+// The catalogs shipped with the UI. English is the default AND the key source; German and Spanish
+// are translations of it.
+//
+// ⚠️ They cross no build step that could check them: `intel build` validates the CUSTOMER's
+// language files against en.json, and these three are already in the package. What replaces that
+// check is `i18n.unit.ts`, which compares the key sets of every file next to en.json. Without it a
+// key added only to en.json would be English text in two other languages, and only a reader using
+// those languages would ever notice.
+const BUILT_IN: Record<string, Catalog> = {
+  en: CatalogSchema.parse(en) as Catalog,
+  de: CatalogSchema.parse(de) as Catalog,
+  es: CatalogSchema.parse(es) as Catalog,
+};
+
+// The language everything falls back to: it is compiled in and can therefore never be missing.
+const FALLBACK = "en";
+
+// custom.json is a build artifact — `intel build` writes it and validates each customer file
+// strictly against en.json. It is still parsed here, because a custom.json from before the switcher
+// is a FLAT catalog: accepting that silently would swap the customer's translation for English
+// without a word.
+const BundleSchema = z.strictObject({
+  defaultLanguage: z.string().min(1),
+  catalogs: z.record(z.string(), CatalogSchema),
+});
+
+export function createLanguages({ store }: LanguagesDeps = {}): Languages {
+  const bundle = BundleSchema.parse(custom);
+  // The built-in catalogs always stand available; the bundle comes last so a customer catalog under
+  // the same code REPLACES the shipped one rather than being ignored. Without that, changing one
+  // sentence of the German UI would mean maintaining a fourth language.
+  const catalogs: Record<string, Catalog> = { ...BUILT_IN, ...bundle.catalogs };
+  const codes = Object.keys(catalogs);
+
+  // A remembered language that no longer exists (the customer removed it from intel.json) is
+  // discarded rather than running half the UI on the English fallback.
+  const remembered = store?.getItem(STORE_KEY);
+  const preferred =
+    remembered !== null && remembered !== undefined && codes.includes(remembered)
+      ? remembered
+      : bundle.defaultLanguage;
+
+  return {
+    codes,
+    initial: codes.includes(preferred) ? preferred : FALLBACK,
+    // An unknown code yields the English instance rather than an empty catalog: `t` would otherwise
+    // return every key verbatim, which looks like a broken screen instead of an untranslated one.
+    i18n: (code) => {
+      const catalog = catalogs[code];
+      return catalog ? createI18n({ catalog }) : createI18n();
+    },
+    remember: (code) => store?.setItem(STORE_KEY, code),
+  };
+}
+
+// A language's name in its own language ("Deutsch", never "German") — that way everybody finds their
+// entry even while the UI is in a language they cannot read. It therefore lives in no catalog: a
+// language the customer adds tomorrow would otherwise need a new key in every language file. A code
+// Intl does not know is shown unchanged.
+export function languageName(code: string): string {
+  try {
+    return new Intl.DisplayNames([code], { type: "language" }).of(code) ?? code;
+  } catch {
+    return code;
+  }
+}

package/src/i18n/i18n.ts

@@ -1,24 +1,28 @@
 import { z } from "zod";
-import custom from "./custom.json";
 import english from "./en.json";
-import type { Catalog, I18n } from "./i18n.types.ts";
+import type { Catalog, I18n, I18nDeps } from "./i18n.types.ts";
+
+// The whole i18n of intel-ui. No framework: i18next and friends bring bundle weight and an
+// abstraction (namespaces, plural rules, loading states) that has no consumer here. What is needed
+// is a lookup plus placeholders — the twenty lines below.
+//
+// English is the default AND the source of keys: en.json is the only file in which a new string is
+// born. A translated catalog arrives as `catalog`; whatever is missing from it falls back to the
+// English text — an incomplete translation shows English words, never an empty screen or a raw key.
+export const CatalogSchema = z.record(z.string(), z.string());
 
-const CatalogSchema = z.record(z.string(), z.string());
-const BundleSchema = z.strictObject({
-  defaultLanguage: z.string().min(1),
-  catalogs: z.record(z.string(), CatalogSchema),
-});
 const fallback = CatalogSchema.parse(english) as Catalog;
-const bundle = BundleSchema.parse(custom);
 
-export function createI18n(language = bundle.defaultLanguage): I18n {
-  const customCatalog = bundle.catalogs[language];
-  const catalog: Catalog = customCatalog ? { ...fallback, ...customCatalog } : fallback;
+export function createI18n({ catalog = fallback }: I18nDeps = {}): I18n {
   return {
     locale: catalog.$locale ?? fallback.$locale ?? "en-US",
     t(key, variables) {
+      // The key itself is the last fallback: a typo becomes visible on screen instead of vanishing
+      // as an empty string.
       const template = catalog[key] ?? fallback[key] ?? key;
       if (!variables) return template;
+      // Only known placeholders are replaced; an unfilled `{foo}` stays put — a visible gap beats a
+      // silent blank.
       return template.replace(/\{(\w+)\}/g, (match, name: string) => {
         const value = variables[name];
         return value === undefined ? match : String(value);