@nullplatform/mcp 0.1.6 → 0.1.8

package/dist/i18n.js

@@ -39,6 +39,8 @@ const english = {
     "header.type": "Type",
     "header.secret": "Secret",
     "header.value": "Value",
+    "header.values": "Values",
+    "header.source": "Source",
     "header.metric": "Metric",
     "header.now": "Now",
     "header.avg": "Avg",
@@ -139,6 +141,9 @@ const english = {
     "params.count.many": "**{app}** · {count} parameters",
     "params.unset": "_unset_",
     "params.applyHint": "changed values apply on the next `application_deployment_create`.",
+    "params.effectiveFor": "**{app}** · effective parameters for **{scope}**",
+    "params.ctxApplication": "Application",
+    "params.ctxScope": "{scope} (scope)",
     "params.errorLabel": "Couldn't list parameters",
     // — application_log_list tool —
     "logs.noun": "Logs",
@@ -146,7 +151,8 @@ const english = {
     "logs.noScopesHint": "`application_deployment_create` after creating a scope — logs appear once something runs.",
     "logs.empty": "No log lines returned for **{app}**{scope}.",
     "logs.openInDashboard": "open logs in dashboard",
-    "logs.lastLines": "**{app}**{scope} — last {count} lines",
+    "logs.lastLines.one": "**{app}**{scope} — last line",
+    "logs.lastLines.many": "**{app}**{scope} — last {count} lines",
     "logs.errorLabel": "Couldn't read logs",
     "logs.errorSuffix": "The dashboard's Logs view may still have them.",
     // — application_metric_list tool —
@@ -158,7 +164,8 @@ const english = {
     "metrics.title": "**{app}** · {scope} — last {window}",
     "metrics.errorLabel": "Couldn't load metrics",
     // — application_build_list tool —
-    "builds.title": "**{app}** · {count} recent build(s)",
+    "builds.title.one": "**{app}** · 1 recent build",
+    "builds.title.many": "**{app}** · {count} recent builds",
     "builds.branch": "Branch",
     "builds.commit": "Commit",
     "builds.released": "Released",
@@ -169,20 +176,25 @@ const english = {
     "builds.waiting": "build #{build} is still running — `application_build_list` again in a moment to check.",
     "builds.upToDate": "the latest successful build is already released.",
     "builds.assetsTitle": "Assets of build #{build}",
-    "builds.noAssets": "Build #{build} has no assets (it may still be building).",
+    "builds.noAssets": "Build #{build} has no assets.",
+    "builds.noAssetsRunning": "Build #{build} has no assets yet — it's still building.",
+    "builds.noAssetsFailed": "Build #{build} failed before producing any assets.",
     "builds.errorLabel": "Couldn't list builds",
-    "releaseList.title": "**{app}** · {count} release(s)",
+    "releaseList.title.one": "**{app}** · 1 release",
+    "releaseList.title.many": "**{app}** · {count} releases",
     "releaseList.none": "**{app}** has no releases yet.",
     "releaseList.noneHint": "cut one from a successful build with `application_release_create`, or just `application_deployment_create`.",
     "releaseList.deployHint": 'deploy an active release with `application_deployment_create version:"x.y.z"`.',
     "releaseList.errorLabel": "Couldn't list releases",
-    "deploymentList.title": "**{app}** · {count} deployment(s)",
+    "deploymentList.title.one": "**{app}** · 1 deployment",
+    "deploymentList.title.many": "**{app}** · {count} deployments",
     "deploymentList.none": "**{app}** has no deployments yet.",
     "deploymentList.group": "{count} scopes (group)",
     "deploymentList.hint": "`application_get` for the live picture, or `application_deployment_update` to drive a rollout.",
     "deploymentList.errorLabel": "Couldn't list deployments",
     // — organization_get tool —
-    "overview.title": "Organization overview · {count} application(s) scanned",
+    "overview.title.one": "Organization overview · 1 application scanned",
+    "overview.title.many": "Organization overview · {count} applications scanned",
     "overview.truncated": '_(showing the first {count} — narrow with `organization_get query:"..."`)_',
     "overview.activeRollouts": "Active rollouts ({count})",
     "overview.trouble": "Needs attention ({count})",
@@ -191,7 +203,8 @@ const english = {
     "overview.hintCalm": "everything is steady — nothing rolling out, nothing failed.",
     "overview.errorLabel": "Couldn't build the overview",
     // — application_approval_list tool —
-    "approvals.title": "**{app}** · {count} approval(s)",
+    "approvals.title.one": "**{app}** · 1 approval",
+    "approvals.title.many": "**{app}** · {count} approvals",
     "approvals.action": "Action",
     "approvals.entity": "Entity",
     "approvals.requestedBy": "Requested by",
@@ -203,12 +216,88 @@ const english = {
     "approvals.actHint": '`application_approval_list action:"approve" approval_id:"{id}"` to let it proceed (uses your permissions).',
     "approvals.errorLabel": "Couldn't load approvals",
     // — application_service_list tool —
-    "services.attached": "**{app}** · {count} dependency service(s)",
+    "services.attached.one": "**{app}** · 1 dependency service",
+    "services.attached.many": "**{app}** · {count} dependency services",
     "services.specification": "Type",
     "services.none": "**{app}** has no dependency services attached.",
     "services.catalog": "Available to provision: {catalog}.",
     "services.provisionHint": "provisioning a dependency is a guided flow — create one in the dashboard.",
     "services.errorLabel": "Couldn't load services",
+    // — application_service_create tool —
+    "createService.errorLabel": "Couldn't provision the service",
+    "createService.noSpecs": "**{app}** has no dependency types available to provision here.",
+    "createService.pickSpec": "**{app}** — which dependency to provision? ({count} available)",
+    "createService.matchAmbiguous": 'Several dependencies match "{query}" — pick one:',
+    "createService.category": "Category",
+    "createService.provider": "Provider",
+    "createService.pickHint": '`application_service_create type:"<name>"` to provision one.',
+    "createService.form": "Ready to provision **{spec}** for **{app}** — submit to create it (this creates real cloud resources).",
+    "createService.formHint": "submit the panel to provision, or pass `provision:true` with the parameters.",
+    "createService.provisioning": "Provisioning **{spec}** as **{name}** — {status}. Real resources are being created.",
+    "createService.reused": "**{name}** already exists ({status}) — reusing it, not provisioning a second one.",
+    "createService.provisioningHint": "`application_link_create` to link **{name}** to a scope — its connection parameters appear after the link, on the next deploy.",
+    // — application_link_create tool —
+    "createLink.errorLabel": "Couldn't create the link",
+    "createLink.noServices": "**{app}** has no provisioned services to link yet.",
+    "createLink.noServicesHint": "`application_service_create` to provision a dependency first.",
+    "createLink.pickService": "Which service to link to **{app}**?",
+    "createLink.matchAmbiguous": "Several services match — pick one:",
+    "createLink.pickHint": '`application_link_create service:"<name>"` to link one.',
+    "createLink.noLinkSpec": "No link specification is available for **{service}** in this org.",
+    "createLink.form": "Ready to link **{service}** to **{app}** — submit to create the link (a credential link provisions a database user).",
+    "createLink.formHint": "submit the panel to create the link, or pass `create:true` with the parameters.",
+    "createLink.linking": "Linking **{service}** to {target} — {status}.",
+    "createLink.reused": "**{service}** is already linked to {target} ({status}) — reusing that link.",
+    "createLink.linkedHint": "redeploy the scope so the new connection parameters reach the runtime.",
+    // — application_service_update / application_link_update (run a custom action) —
+    "runAction.errorLabel": "Couldn't run the action",
+    "runAction.noServices": "**{app}** has no provisioned services to run an action on.",
+    "runAction.noServicesHint": "`application_service_create` to provision a dependency first.",
+    "runAction.noLinks": "**{app}** has no links to run an action on.",
+    "runAction.noLinksHint": "`application_link_create` to link a service first.",
+    "runAction.pickService": "Which service to run an action on, in **{app}**?",
+    "runAction.serviceAmbiguous": "Several services match — pick one:",
+    "runAction.pickServiceHint": '`application_service_update service:"<name>"` to choose one.',
+    "runAction.pickLink": "Which link to run an action on, in **{app}**?",
+    "runAction.linkAmbiguous": "Several links match — pick one:",
+    "runAction.pickLinkHint": '`application_link_update link:"<name>"` to choose one.',
+    "runAction.noActions": "**{name}** exposes no runnable actions.",
+    "runAction.pickAction": "Which action to run on **{name}**?",
+    "runAction.matchAmbiguous": "Several actions match — pick one:",
+    "runAction.paramsHeader": "Parameters",
+    "runAction.pickHint": 'Pass `action:"<name>"` to choose one.',
+    "runAction.form": "Ready to run **{action}** on **{name}** — submit to run it.",
+    "runAction.formHint": "submit the panel to run it, or pass `run:true` with the parameters.",
+    "runAction.running": "Running **{action}** on **{name}** — {status}.",
+    "runAction.ranHint": "the action runs asynchronously; its result appears when it finishes.",
+    // — application_service_delete / application_link_delete (deprovision) —
+    "deleteEntity.serviceErrorLabel": "Couldn't delete the service",
+    "deleteEntity.linkErrorLabel": "Couldn't delete the link",
+    "deleteEntity.noServices": "**{app}** has no provisioned services to delete.",
+    "deleteEntity.noLinks": "**{app}** has no links to delete.",
+    "deleteEntity.pickService": "Which service to delete, in **{app}**?",
+    "deleteEntity.serviceAmbiguous": "Several services match — pick one:",
+    "deleteEntity.pickServiceHint": '`application_service_delete service:"<name>"` to choose one.',
+    "deleteEntity.pickLink": "Which link to delete, in **{app}**?",
+    "deleteEntity.linkAmbiguous": "Several links match — pick one:",
+    "deleteEntity.pickLinkHint": '`application_link_delete link:"<name>"` to choose one.',
+    "deleteEntity.hasLinks": "**{name}** still has {count} active link(s) — they'd be orphaned.",
+    "deleteEntity.hasLinksHint": "delete the links first with `application_link_delete`, then the service.",
+    "deleteEntity.confirm": "Ready to delete **{name}** and destroy its resources — submit to confirm.",
+    "deleteEntity.confirmHint": "submit the panel to delete, or pass `confirm:true`.",
+    "deleteEntity.removed": "**{name}** was deleted.",
+    "deleteEntity.deprovisioning": "Deleting **{name}** — an agent is deprovisioning its resources.",
+    "deleteEntity.deprovisioningHint": "the record is removed once deprovisioning finishes.",
+    // — application_parameter_delete tool —
+    "deleteParam.errorLabel": "Couldn't delete the parameter",
+    "deleteParam.absent": "**{name}** isn't set on **{app}** — nothing to delete.",
+    "deleteParam.readOnly": "**{name}** is read-only — a service link injects it.",
+    "deleteParam.readOnlyHint": "delete the link that exports it with `application_link_delete`.",
+    "deleteParam.confirm": "Ready to delete **{name}** from **{app}** — submit to confirm.",
+    "deleteParam.confirmHint": "submit the panel to delete, or pass `confirm:true`.",
+    "deleteParam.deleted": "Deleted **{name}** from **{app}**.",
+    "deleteParam.deletedHint": "the change applies on the next deploy.",
+    "deleteParam.failed": "Couldn't delete **{name}**: {message}",
     // — application_deployment_create tool —
     "deploy.noScopeTypes": "This app has no scopes yet. Available scope types: {types}.",
     "deploy.createScopeHint": '`application_scope_create name:"dev" type:"{type}"`',
@@ -238,16 +327,20 @@ const english = {
     "createRelease.deployHint": "`application_deployment_create release_id:{id}` to ship it.",
     "createRelease.errorLabel": "Couldn't create release",
     // — application_parameter_create tool —
-    "setParams.created": "Set {count} new parameter(s) on **{app}**: {names}.",
-    "setParams.updated": "Updated {count} existing parameter(s) on **{app}**: {names}.",
-    "setParams.mixed": "Set {created} new and updated {updated} parameter(s) on **{app}**: {names}.",
+    "setParams.created.one": "Set 1 new parameter on **{app}**: {names}.",
+    "setParams.created.many": "Set {count} new parameters on **{app}**: {names}.",
+    "setParams.updated.one": "Updated 1 existing parameter on **{app}**: {names}.",
+    "setParams.updated.many": "Updated {count} existing parameters on **{app}**: {names}.",
+    "setParams.mixed": "Set {total} parameters on **{app}** (new: {created}, updated: {updated}): {names}.",
     "setParams.applyHint": "values apply on the next `application_deployment_create`.",
+    "setParams.scopeDimConflict": "Can't target both a scope and dimensions for `{name}` — a scope already locates the value. Pick one.",
     "setParams.partial": "Parameter update failed partway: {message}\nAlready-created parameters remain — `application_parameter_list` to inspect.",
     "setParams.errorLabel": "Parameter update failed",
     // — application_create tool —
     "createApp.form": "To create an application I need a git repository URL and a name (the form collects them).\nNamespaces: {namespaces}.",
     "createApp.noName": "Couldn't derive a name from {url} — pass name.",
     "createApp.noNamespaceMatch": 'No namespace matching "{namespace}". Namespaces: {names}.',
+    "createApp.noAccountMatch": 'No account matching "{account}". Accounts: {names}.',
     "createApp.whichNamespace": "Which namespace?",
     "createApp.whichNamespaceFor": "Which namespace should own **{name}**?",
     "createApp.namespaceHint": '`application_create namespace:"<name>"`',
@@ -255,6 +348,7 @@ const english = {
     "createApp.created": "**{name}** created (#{id}) in namespace **{namespace}**, linked to {repo}.",
     "createApp.alreadyLinked": "**{name}** (#{id}) is already linked to {repo} — nothing to create.",
     "createApp.createdHint": "push a commit to trigger the first build, then `application_deployment_create`.",
+    "createApp.createdHintNew": "the repo was scaffolded for you — clone {repo} into a folder, add your code there, and push so CI builds it, then `application_deployment_create`.",
     "createApp.pending": "⏳ **{name}** created (#{id}), provisioning is still running (status: {status}).",
     "createApp.pendingHint": '`application_get app:"#{id}"` to check on it.',
     "createApp.errorLabel": "Couldn't create the application",
@@ -326,6 +420,8 @@ const spanish = {
     "header.type": "Tipo",
     "header.secret": "Secreto",
     "header.value": "Valor",
+    "header.values": "Valores",
+    "header.source": "Origen",
     "header.metric": "Métrica",
     "header.now": "Ahora",
     "header.avg": "Prom",
@@ -418,13 +514,17 @@ const spanish = {
     "params.count.many": "**{app}** · {count} parámetros",
     "params.unset": "_sin valor_",
     "params.applyHint": "los valores cambiados aplican en el próximo `application_deployment_create`.",
+    "params.effectiveFor": "**{app}** · parámetros efectivos para **{scope}**",
+    "params.ctxApplication": "Aplicación",
+    "params.ctxScope": "{scope} (scope)",
     "params.errorLabel": "No pude listar los parámetros",
     "logs.noun": "Los logs",
     "logs.noScopes": "**{app}** no tiene scopes, así que todavía no hay logs de runtime.",
     "logs.noScopesHint": "`application_deployment_create` después de crear un scope — los logs aparecen cuando algo corre.",
     "logs.empty": "No hay líneas de log para **{app}**{scope}.",
     "logs.openInDashboard": "abrir logs en el dashboard",
-    "logs.lastLines": "**{app}**{scope} — últimas {count} líneas",
+    "logs.lastLines.one": "**{app}**{scope} — última línea",
+    "logs.lastLines.many": "**{app}**{scope} — últimas {count} líneas",
     "logs.errorLabel": "No pude leer los logs",
     "logs.errorSuffix": "La vista Logs del dashboard puede tenerlos igual.",
     "metrics.noun": "Las métricas",
@@ -435,7 +535,8 @@ const spanish = {
     "metrics.title": "**{app}** · {scope} — últimas {window}",
     "metrics.errorLabel": "No pude cargar las métricas",
     // — application_build_list tool —
-    "builds.title": "**{app}** · {count} build(s) reciente(s)",
+    "builds.title.one": "**{app}** · 1 build reciente",
+    "builds.title.many": "**{app}** · {count} builds recientes",
     "builds.branch": "Branch",
     "builds.commit": "Commit",
     "builds.released": "Released",
@@ -446,20 +547,25 @@ const spanish = {
     "builds.waiting": "el build #{build} sigue corriendo — `application_build_list` de nuevo en un momento para chequear.",
     "builds.upToDate": "el último build exitoso ya está publicado.",
     "builds.assetsTitle": "Assets del build #{build}",
-    "builds.noAssets": "El build #{build} no tiene assets (puede estar compilando todavía).",
+    "builds.noAssets": "El build #{build} no tiene assets.",
+    "builds.noAssetsRunning": "El build #{build} todavía no tiene assets — sigue compilando.",
+    "builds.noAssetsFailed": "El build #{build} falló antes de producir assets.",
     "builds.errorLabel": "No pude listar los builds",
-    "releaseList.title": "**{app}** · {count} release(s)",
+    "releaseList.title.one": "**{app}** · 1 release",
+    "releaseList.title.many": "**{app}** · {count} releases",
     "releaseList.none": "**{app}** todavía no tiene releases.",
     "releaseList.noneHint": "cortá uno desde un build exitoso con `application_release_create`, o directamente `application_deployment_create`.",
     "releaseList.deployHint": 'deployá un release activo con `application_deployment_create version:"x.y.z"`.',
     "releaseList.errorLabel": "No pude listar los releases",
-    "deploymentList.title": "**{app}** · {count} deployment(s)",
+    "deploymentList.title.one": "**{app}** · 1 deployment",
+    "deploymentList.title.many": "**{app}** · {count} deployments",
     "deploymentList.none": "**{app}** todavía no tiene deployments.",
     "deploymentList.group": "{count} scopes (grupo)",
     "deploymentList.hint": "`application_get` para la foto en vivo, o `application_deployment_update` para conducir un rollout.",
     "deploymentList.errorLabel": "No pude listar los deployments",
     // — organization_get tool —
-    "overview.title": "Panorama de la organización · {count} aplicación(es) escaneada(s)",
+    "overview.title.one": "Panorama de la organización · 1 aplicación escaneada",
+    "overview.title.many": "Panorama de la organización · {count} aplicaciones escaneadas",
     "overview.truncated": '_(muestro las primeras {count} — acotá con `organization_get query:"..."`)_',
     "overview.activeRollouts": "Rollouts activos ({count})",
     "overview.trouble": "Requiere atención ({count})",
@@ -468,7 +574,8 @@ const spanish = {
     "overview.hintCalm": "todo tranquilo — nada desplegándose, nada falló.",
     "overview.errorLabel": "No pude armar el panorama",
     // — application_approval_list tool —
-    "approvals.title": "**{app}** · {count} aprobación(es)",
+    "approvals.title.one": "**{app}** · 1 aprobación",
+    "approvals.title.many": "**{app}** · {count} aprobaciones",
     "approvals.action": "Acción",
     "approvals.entity": "Entidad",
     "approvals.requestedBy": "Solicitada por",
@@ -480,12 +587,88 @@ const spanish = {
     "approvals.actHint": '`application_approval_list action:"approve" approval_id:"{id}"` para dejarla continuar (usa tus permisos).',
     "approvals.errorLabel": "No pude cargar las aprobaciones",
     // — application_service_list tool —
-    "services.attached": "**{app}** · {count} servicio(s) de dependencia",
+    "services.attached.one": "**{app}** · 1 servicio de dependencia",
+    "services.attached.many": "**{app}** · {count} servicios de dependencia",
     "services.specification": "Tipo",
     "services.none": "**{app}** no tiene servicios de dependencia conectados.",
     "services.catalog": "Disponibles para aprovisionar: {catalog}.",
     "services.provisionHint": "aprovisionar una dependencia es un flujo guiado — creala en el dashboard.",
     "services.errorLabel": "No pude cargar los servicios",
+    // — application_service_create tool —
+    "createService.errorLabel": "No pude provisionar el servicio",
+    "createService.noSpecs": "**{app}** no tiene tipos de dependencia disponibles para provisionar acá.",
+    "createService.pickSpec": "**{app}** — ¿qué dependencia provisionar? ({count} disponibles)",
+    "createService.matchAmbiguous": 'Varias dependencias coinciden con "{query}" — elegí una:',
+    "createService.category": "Categoría",
+    "createService.provider": "Proveedor",
+    "createService.pickHint": '`application_service_create type:"<nombre>"` para provisionar una.',
+    "createService.form": "Listo para provisionar **{spec}** en **{app}** — confirmá para crearlo (crea recursos cloud reales).",
+    "createService.formHint": "confirmá en el panel para provisionar, o pasá `provision:true` con los parámetros.",
+    "createService.provisioning": "Provisionando **{spec}** como **{name}** — {status}. Se están creando recursos reales.",
+    "createService.reused": "**{name}** ya existe ({status}) — lo reuso, no provisiono un segundo.",
+    "createService.provisioningHint": "`application_link_create` para linkear **{name}** a un scope — sus parámetros de conexión aparecen después del link, en el próximo deploy.",
+    // — application_link_create tool —
+    "createLink.errorLabel": "No pude crear el link",
+    "createLink.noServices": "**{app}** todavía no tiene servicios provisionados para linkear.",
+    "createLink.noServicesHint": "`application_service_create` para provisionar una dependencia primero.",
+    "createLink.pickService": "¿Qué servicio linkear a **{app}**?",
+    "createLink.matchAmbiguous": "Varios servicios coinciden — elegí uno:",
+    "createLink.pickHint": '`application_link_create service:"<nombre>"` para linkear uno.',
+    "createLink.noLinkSpec": "No hay link specification disponible para **{service}** en esta org.",
+    "createLink.form": "Listo para linkear **{service}** a **{app}** — confirmá para crear el link (un link de credenciales provisiona un usuario de base de datos).",
+    "createLink.formHint": "confirmá en el panel para crear el link, o pasá `create:true` con los parámetros.",
+    "createLink.linking": "Linkeando **{service}** a {target} — {status}.",
+    "createLink.reused": "**{service}** ya está linkeado a {target} ({status}) — reuso ese link.",
+    "createLink.linkedHint": "redeployá el scope para que los nuevos parámetros de conexión lleguen al runtime.",
+    // — application_service_update / application_link_update (correr una custom action) —
+    "runAction.errorLabel": "No pude correr la acción",
+    "runAction.noServices": "**{app}** no tiene servicios provisionados para correr una acción.",
+    "runAction.noServicesHint": "`application_service_create` para provisionar una dependencia primero.",
+    "runAction.noLinks": "**{app}** no tiene links para correr una acción.",
+    "runAction.noLinksHint": "`application_link_create` para linkear un servicio primero.",
+    "runAction.pickService": "¿En qué servicio correr una acción, en **{app}**?",
+    "runAction.serviceAmbiguous": "Varios servicios coinciden — elegí uno:",
+    "runAction.pickServiceHint": '`application_service_update service:"<nombre>"` para elegir uno.',
+    "runAction.pickLink": "¿En qué link correr una acción, en **{app}**?",
+    "runAction.linkAmbiguous": "Varios links coinciden — elegí uno:",
+    "runAction.pickLinkHint": '`application_link_update link:"<nombre>"` para elegir uno.',
+    "runAction.noActions": "**{name}** no expone acciones ejecutables.",
+    "runAction.pickAction": "¿Qué acción correr en **{name}**?",
+    "runAction.matchAmbiguous": "Varias acciones coinciden — elegí una:",
+    "runAction.paramsHeader": "Parámetros",
+    "runAction.pickHint": 'Pasá `action:"<nombre>"` para elegir una.',
+    "runAction.form": "Listo para correr **{action}** en **{name}** — confirmá para ejecutarla.",
+    "runAction.formHint": "confirmá en el panel para correrla, o pasá `run:true` con los parámetros.",
+    "runAction.running": "Corriendo **{action}** en **{name}** — {status}.",
+    "runAction.ranHint": "la acción corre de forma asíncrona; su resultado aparece cuando termina.",
+    // — application_service_delete / application_link_delete (deprovision) —
+    "deleteEntity.serviceErrorLabel": "No pude borrar el servicio",
+    "deleteEntity.linkErrorLabel": "No pude borrar el link",
+    "deleteEntity.noServices": "**{app}** no tiene servicios provisionados para borrar.",
+    "deleteEntity.noLinks": "**{app}** no tiene links para borrar.",
+    "deleteEntity.pickService": "¿Qué servicio borrar, en **{app}**?",
+    "deleteEntity.serviceAmbiguous": "Varios servicios coinciden — elegí uno:",
+    "deleteEntity.pickServiceHint": '`application_service_delete service:"<nombre>"` para elegir uno.',
+    "deleteEntity.pickLink": "¿Qué link borrar, en **{app}**?",
+    "deleteEntity.linkAmbiguous": "Varios links coinciden — elegí uno:",
+    "deleteEntity.pickLinkHint": '`application_link_delete link:"<nombre>"` para elegir uno.',
+    "deleteEntity.hasLinks": "**{name}** todavía tiene {count} link(s) activo(s) — quedarían huérfanos.",
+    "deleteEntity.hasLinksHint": "borrá los links primero con `application_link_delete`, después el servicio.",
+    "deleteEntity.confirm": "Listo para borrar **{name}** y destruir sus recursos — confirmá para borrar.",
+    "deleteEntity.confirmHint": "confirmá en el panel para borrar, o pasá `confirm:true`.",
+    "deleteEntity.removed": "**{name}** fue borrado.",
+    "deleteEntity.deprovisioning": "Borrando **{name}** — un agente está desaprovisionando sus recursos.",
+    "deleteEntity.deprovisioningHint": "el registro se elimina cuando termina el desaprovisionamiento.",
+    // — application_parameter_delete tool —
+    "deleteParam.errorLabel": "No pude borrar el parámetro",
+    "deleteParam.absent": "**{name}** no está seteado en **{app}** — nada que borrar.",
+    "deleteParam.readOnly": "**{name}** es de solo lectura — lo inyecta un link de servicio.",
+    "deleteParam.readOnlyHint": "borrá el link que lo exporta con `application_link_delete`.",
+    "deleteParam.confirm": "Listo para borrar **{name}** de **{app}** — confirmá para borrar.",
+    "deleteParam.confirmHint": "confirmá en el panel para borrar, o pasá `confirm:true`.",
+    "deleteParam.deleted": "Borré **{name}** de **{app}**.",
+    "deleteParam.deletedHint": "el cambio aplica en el próximo deploy.",
+    "deleteParam.failed": "No pude borrar **{name}**: {message}",
     "deploy.noScopeTypes": "Esta app no tiene scopes todavía. Tipos de scope disponibles: {types}.",
     "deploy.createScopeHint": '`application_scope_create name:"dev" type:"{type}"`',
     "deploy.usingRelease": "Usando la release existente **{semver}** (#{id}). ",
@@ -511,15 +694,19 @@ const spanish = {
     "createRelease.from": " desde el build #{build} ({branch} @{commit}, {when})",
     "createRelease.deployHint": "`application_deployment_create release_id:{id}` para publicarla.",
     "createRelease.errorLabel": "No pude crear la release",
-    "setParams.created": "Configuré {count} parámetro(s) nuevo(s) en **{app}**: {names}.",
-    "setParams.updated": "Actualicé {count} parámetro(s) existente(s) en **{app}**: {names}.",
-    "setParams.mixed": "Configuré {created} nuevo(s) y actualicé {updated} parámetro(s) en **{app}**: {names}.",
+    "setParams.created.one": "Configuré 1 parámetro nuevo en **{app}**: {names}.",
+    "setParams.created.many": "Configuré {count} parámetros nuevos en **{app}**: {names}.",
+    "setParams.updated.one": "Actualicé 1 parámetro existente en **{app}**: {names}.",
+    "setParams.updated.many": "Actualicé {count} parámetros existentes en **{app}**: {names}.",
+    "setParams.mixed": "Configuré {total} parámetros en **{app}** (nuevos: {created}, actualizados: {updated}): {names}.",
     "setParams.applyHint": "los valores aplican en el próximo `application_deployment_create`.",
+    "setParams.scopeDimConflict": "No se puede apuntar a un scope y dimensiones a la vez para `{name}` — el scope ya ubica el valor. Elegí uno.",
     "setParams.partial": "La actualización de parámetros falló a mitad de camino: {message}\nLos parámetros ya creados quedan — `application_parameter_list` para inspeccionar.",
     "setParams.errorLabel": "Falló la actualización de parámetros",
     "createApp.form": "Para crear una aplicación necesito la URL de un repo git y un nombre (el formulario los pide).\nNamespaces: {namespaces}.",
     "createApp.noName": "No pude derivar un nombre desde {url} — pasá name.",
     "createApp.noNamespaceMatch": 'Ningún namespace coincide con "{namespace}". Namespaces: {names}.',
+    "createApp.noAccountMatch": 'Ninguna cuenta coincide con "{account}". Cuentas: {names}.',
     "createApp.whichNamespace": "¿Qué namespace?",
     "createApp.whichNamespaceFor": "¿Qué namespace debería ser dueño de **{name}**?",
     "createApp.namespaceHint": '`application_create namespace:"<nombre>"`',
@@ -527,6 +714,7 @@ const spanish = {
     "createApp.created": "**{name}** creada (#{id}) en el namespace **{namespace}**, vinculada a {repo}.",
     "createApp.alreadyLinked": "**{name}** (#{id}) ya está vinculada a {repo} — no hay nada que crear.",
     "createApp.createdHint": "pusheá un commit para disparar el primer build y después `application_deployment_create`.",
+    "createApp.createdHintNew": "el repo fue scaffoldeado — cloná {repo} en una carpeta, agregá tu código ahí y pusheá para que CI buildee, después `application_deployment_create`.",
     "createApp.pending": "⏳ **{name}** creada (#{id}), el aprovisionamiento sigue corriendo (estado: {status}).",
     "createApp.pendingHint": '`application_get app:"#{id}"` para revisarla.',
     "createApp.errorLabel": "No pude crear la aplicación",
@@ -567,8 +755,392 @@ const spanish = {
 Cerrá con un veredicto de un párrafo: sano / degradado / en problemas, y la próxima acción más útil.`,
     "prompt.rollback": `Algo está mal — revertí {app} ya mismo: encontrá su rollout activo, corré application_deployment_update action:"rollback" y confirmá con application_get que la versión anterior está sirviendo tráfico; resumí qué se revirtió.`,
 };
-const catalogs = { en: english, es: spanish };
-const SUPPORTED = ["en", "es"];
+const portuguese = {
+    // — resolution (which app?) —
+    "resolve.ambiguous": "Várias aplicações coincidem — diga qual (nome ou `#id`):",
+    "resolve.noId": "Nenhuma aplicação com id {id}.",
+    "resolve.noMatch": 'Nenhuma aplicação correspondente a "{ref}".',
+    "resolve.repoUnlinked": 'Este repositório ({url}) não está vinculado a nenhuma aplicação nullplatform. Passe app:"<nome>" ou rode application_create para vinculá-lo.',
+    "resolve.noInput": 'Nenhuma app informada e nenhum remote git encontrado no workspace. Passe app:"<nome>" (ou um id como "#123").',
+    "resolve.noNrn": "Não consigo resolver o NRN da aplicação para **{app}**.",
+    // — scope selection —
+    "scope.which": "Qual scope?",
+    "scope.none": "Esta app ainda não tem scopes.",
+    "scope.noneHint": '`application_scope_create name:"dev"` primeiro — depois `application_deployment_create`.',
+    "scope.noMatch": 'Nenhum scope correspondente a "{wanted}". Scopes: {names}.',
+    "scope.noMatchDetailed": 'Nenhum scope correspondente a "{wanted}" (por nome ou dimensão). Scopes:',
+    "scope.createHint": '`application_scope_create name:"{name}"` para criá-lo.',
+    "scope.deployHint": '`application_deployment_create scope:"<nome ou dimensão, ex. environment=production>"`',
+    "scope.perScope": "{noun} são por scope — qual?",
+    "scope.readHint": '`{tool} scope:"{name}"`',
+    // — table headers —
+    "header.app": "App",
+    "header.id": "Id",
+    "header.namespace": "Namespace",
+    "header.account": "Conta",
+    "header.status": "Status",
+    "header.scope": "Scope",
+    "header.dimensions": "Dimensões",
+    "header.name": "Nome",
+    "header.variable": "Variável",
+    "header.type": "Tipo",
+    "header.secret": "Secret",
+    "header.value": "Valor",
+    "header.values": "Valores",
+    "header.source": "Origem",
+    "header.metric": "Métrica",
+    "header.now": "Agora",
+    "header.avg": "Méd",
+    "header.max": "Máx",
+    "header.trend": "Tendência",
+    "header.asset": "Asset",
+    "header.platform": "Plataforma",
+    "header.deployment": "Deployment",
+    "header.provider": "Provider",
+    "header.live": "No ar",
+    "header.traffic": "Tráfego",
+    "header.when": "Quando",
+    "header.version": "Versão",
+    "header.build": "Build",
+    "header.release": "Release",
+    // — markdown design language —
+    "md.next": "Próximo",
+    "md.none": "_nenhum_",
+    "md.justNow": "agora mesmo",
+    "md.minutesAgo": "há {count}m",
+    "md.hoursAgo": "há {count}h",
+    "md.daysAgo": "há {count}d",
+    "md.dashboard": "dashboard",
+    "md.unknown": "desconhecido",
+    // — platform status words (fallback: raw status with underscores spaced) —
+    "status.active": "ativo",
+    "status.successful": "bem-sucedido",
+    "status.finalized": "finalizado",
+    "status.running": "em execução",
+    "status.pending": "pendente",
+    "status.creating": "criando",
+    "status.updating": "atualizando",
+    "status.building": "em build",
+    "status.waiting_for_instances": "aguardando instâncias",
+    "status.switching_traffic": "trocando tráfego",
+    "status.finalizing": "finalizando",
+    "status.cancelling": "cancelando",
+    "status.rolling_back": "revertendo",
+    "status.creating_approval": "aguardando aprovação",
+    "status.failed": "falhou",
+    "status.cancelled": "cancelado",
+    "status.rolled_back": "revertido",
+    "status.deleted": "deletado",
+    "status.inactive": "inativo",
+    "status.creating_approval_denied": "aprovação negada",
+    // — status view —
+    "render.noScopes": "_Ainda sem scopes — nada para fazer deploy._",
+    "render.nothingDeployed": "_nada em deploy_",
+    "render.noBuilds": "_nenhum — faça push para o CI_",
+    "render.latestBuild": "Último build",
+    "render.releases": "Releases",
+    "render.liveOn": "no ar em {scopes}",
+    "render.deployment": "**Deployment**",
+    "render.deploying": "🚀 **Fazendo deploy**",
+    "render.release": "Release",
+    "render.started": "iniciado {when}",
+    "render.now": "agora",
+    "render.desired": "→ desejado {pct}%",
+    // — next-step hints (status) —
+    "hint.rolloutTraffic": 'deployment #{id} em **{scope}** está com {traffic}% de tráfego — `application_deployment_update percent:<n>` para avançar, `application_deployment_update action:"finalize"` quando pronto, `application_deployment_update action:"rollback"` para reverter.',
+    "hint.rolloutStatus": "deployment #{id} em **{scope}** está {status} — `application_get deployment:{id}` para acompanhar.",
+    "hint.noScopes": 'ainda sem scopes — `application_scope_create name:"dev"` para ter onde fazer deploy.',
+    "hint.buildNewer": "build #{id} ({branch} @{commit}) é mais novo que a release {semver} — `application_deployment_create` faz o deploy (cria a release para você).",
+    "hint.buildUnreleased": "build #{id} ainda não tem release — `application_deployment_create` faz o deploy (cria a release para você).",
+    "hint.releaseNotLive": "a release {semver} ainda não está no ar — `application_deployment_create` para publicá-la.",
+    "hint.noBuilds": "ainda sem builds — faça push de um commit para o CI gerar um, depois `application_deployment_create`.",
+    "hint.upToDate": "está tudo atualizado ✅",
+    "hint.watch": "`application_get deployment:{id}` para acompanhar.",
+    // — next-step hints (rollout) —
+    "rollout.full": 'todo o tráfego na nova versão — `application_deployment_update action:"finalize"` para aposentar a antiga.',
+    "rollout.moving": "tráfego indo de {from}% → {to}% — `application_get deployment:{id}` para acompanhar.",
+    "rollout.at": 'tráfego em {traffic}% — `application_deployment_update percent:<n>` para avançar (marcas: 1,5,10,25,50,75,90,95,99,100), `application_deployment_update action:"rollback"` para reverter.',
+    "rollout.instances": "as instâncias estão subindo — `application_get deployment:{id}` para acompanhar.",
+    "rollout.switching": "o tráfego está sendo trocado — `application_get deployment:{id}` para acompanhar.",
+    "rollout.finalizing": "finalizando — as instâncias antigas estão sendo aposentadas.",
+    "rollout.done": "pronto — a release está totalmente no ar ✅",
+    "rollout.approval": "aguardando uma aprovação ✋ — um aprovador precisa liberar este deployment (dashboard → Aprovações).",
+    "rollout.failed": 'o deployment falhou — `application_log_list` para ver a saída, `application_deployment_update action:"rollback"` se o tráfego se moveu.',
+    "rollout.rolledBack": "revertido — a versão anterior está atendendo todo o tráfego.",
+    // — application_get tool —
+    "status.errorLabel": "Não foi possível carregar o status",
+    // — application_list tool —
+    "findApps.noneMatching": "Nenhuma aplicação{matching}{inNamespace}.",
+    "findApps.matching": ' correspondente a "{query}"',
+    "findApps.inNamespace": ' nos namespaces ~"{namespace}"',
+    "findApps.createHint": "`application_create` vincula este repositório como uma nova aplicação.",
+    "findApps.count.one": "1 aplicação",
+    "findApps.count.many": "{count} aplicações",
+    "findApps.statusHint": '`application_get app:"<nome>"` para o panorama completo de uma.',
+    "findApps.truncated": "Mostrando as primeiras {shown} — refine com uma query ou namespace para ver o resto.",
+    "findApps.errorLabel": "Busca falhou",
+    // — application_parameter_list tool —
+    "params.unavailable": "A listagem de parâmetros não está disponível aqui. `application_parameter_create` ainda funciona.",
+    "params.viewInDashboard": "ver no dashboard",
+    "params.none": "**{app}** não tem parâmetros.",
+    "params.noneHint": "`application_parameter_create` para adicionar variáveis de ambiente ou arquivos.",
+    "params.count.one": "**{app}** · 1 parâmetro",
+    "params.count.many": "**{app}** · {count} parâmetros",
+    "params.unset": "_não definido_",
+    "params.applyHint": "valores alterados aplicam no próximo `application_deployment_create`.",
+    "params.effectiveFor": "**{app}** · parâmetros efetivos para **{scope}**",
+    "params.ctxApplication": "Aplicação",
+    "params.ctxScope": "{scope} (scope)",
+    "params.errorLabel": "Não foi possível listar os parâmetros",
+    // — application_log_list tool —
+    "logs.noun": "Logs",
+    "logs.noScopes": "**{app}** não tem scopes, então ainda não há logs de runtime.",
+    "logs.noScopesHint": "`application_deployment_create` depois de criar um scope — os logs aparecem quando algo roda.",
+    "logs.empty": "Nenhuma linha de log retornada para **{app}**{scope}.",
+    "logs.openInDashboard": "abrir logs no dashboard",
+    "logs.lastLines.one": "**{app}**{scope} — última linha",
+    "logs.lastLines.many": "**{app}**{scope} — últimas {count} linhas",
+    "logs.errorLabel": "Não foi possível ler os logs",
+    "logs.errorSuffix": "A visão de Logs do dashboard ainda pode tê-los.",
+    // — application_metric_list tool —
+    "metrics.noun": "Métricas",
+    "metrics.noScopes": "**{app}** não tem scopes, então ainda não há métricas de runtime.",
+    "metrics.noScopesHint": "`application_deployment_create` depois de criar um scope.",
+    "metrics.empty": "Nenhum datapoint de métrica para **{app}** · {scope} nos últimos {window} — o scope pode ser recente ou o agente de métricas não está configurado.",
+    "metrics.openInDashboard": "performance no dashboard",
+    "metrics.title": "**{app}** · {scope} — últimos {window}",
+    "metrics.errorLabel": "Não foi possível carregar as métricas",
+    // — application_build_list tool —
+    "builds.title.one": "**{app}** · 1 build recente",
+    "builds.title.many": "**{app}** · {count} builds recentes",
+    "builds.branch": "Branch",
+    "builds.commit": "Commit",
+    "builds.released": "Com release",
+    "builds.none": "**{app}** ainda não tem builds.",
+    "builds.noneForCommit": "Nenhum build em **{app}** para o commit `{commit}` — pode não ter buildado ainda, ou o commit não está em uma branch buildada.",
+    "builds.noneHint": "faça push de um commit para o CI gerar um, depois `application_deployment_create`.",
+    "builds.deployHint": "`application_deployment_create build_id:{build}` faz o deploy (corta a release para você).",
+    "builds.waiting": "o build #{build} ainda está rodando — `application_build_list` de novo em instantes para checar.",
+    "builds.upToDate": "o último build bem-sucedido já tem release.",
+    "builds.assetsTitle": "Assets do build #{build}",
+    "builds.noAssets": "O build #{build} não tem assets.",
+    "builds.noAssetsRunning": "O build #{build} ainda não tem assets — ainda está buildando.",
+    "builds.noAssetsFailed": "O build #{build} falhou antes de produzir qualquer asset.",
+    "builds.errorLabel": "Não foi possível listar os builds",
+    "releaseList.title.one": "**{app}** · 1 release",
+    "releaseList.title.many": "**{app}** · {count} releases",
+    "releaseList.none": "**{app}** ainda não tem releases.",
+    "releaseList.noneHint": "corte uma a partir de um build bem-sucedido com `application_release_create`, ou simplesmente `application_deployment_create`.",
+    "releaseList.deployHint": 'faça deploy de uma release ativa com `application_deployment_create version:"x.y.z"`.',
+    "releaseList.errorLabel": "Não foi possível listar as releases",
+    "deploymentList.title.one": "**{app}** · 1 deployment",
+    "deploymentList.title.many": "**{app}** · {count} deployments",
+    "deploymentList.none": "**{app}** ainda não tem deployments.",
+    "deploymentList.group": "{count} scopes (grupo)",
+    "deploymentList.hint": "`application_get` para o panorama ao vivo, ou `application_deployment_update` para conduzir um rollout.",
+    "deploymentList.errorLabel": "Não foi possível listar os deployments",
+    // — organization_get tool —
+    "overview.title.one": "Visão geral da organização · 1 aplicação escaneada",
+    "overview.title.many": "Visão geral da organização · {count} aplicações escaneadas",
+    "overview.truncated": '_(mostrando as primeiras {count} — refine com `organization_get query:"..."`)_',
+    "overview.activeRollouts": "Rollouts ativos ({count})",
+    "overview.trouble": "Precisa de atenção ({count})",
+    "overview.hintActive": '`application_get app:"{app}"` para acompanhar um rollout, ou `application_deployment_update` para conduzir um.',
+    "overview.hintTrouble": '`application_log_list app:"{app}"` para investigar, `application_deployment_update action:"rollback"` se necessário.',
+    "overview.hintCalm": "está tudo estável — nada em rollout, nada falhou.",
+    "overview.errorLabel": "Não foi possível montar a visão geral",
+    // — application_approval_list tool —
+    "approvals.title.one": "**{app}** · 1 aprovação",
+    "approvals.title.many": "**{app}** · {count} aprovações",
+    "approvals.action": "Ação",
+    "approvals.entity": "Entidade",
+    "approvals.requestedBy": "Solicitado por",
+    "approvals.none": "Nenhuma aprovação pendente para **{app}**.",
+    "approvals.needId": "Passe `approval_id` junto com a ação.",
+    "approvals.invalidId": "Isso não parece um approval id válido — copie-o da lista do `application_approval_list`.",
+    "approvals.approved": "Aprovado {id} — a ação bloqueada pode prosseguir.",
+    "approvals.cancelled": "Aprovação {id} cancelada.",
+    "approvals.actHint": '`application_approval_list action:"approve" approval_id:"{id}"` para liberá-la (usa suas permissões).',
+    "approvals.errorLabel": "Não foi possível carregar as aprovações",
+    // — application_service_list tool —
+    "services.attached.one": "**{app}** · 1 serviço de dependência",
+    "services.attached.many": "**{app}** · {count} serviços de dependência",
+    "services.specification": "Tipo",
+    "services.none": "**{app}** não tem serviços de dependência anexados.",
+    "services.catalog": "Disponíveis para provisionar: {catalog}.",
+    "services.provisionHint": "provisionar uma dependência é um fluxo guiado — crie uma no dashboard.",
+    "services.errorLabel": "Não foi possível carregar os serviços",
+    // — application_service_create tool —
+    "createService.errorLabel": "Não foi possível provisionar o serviço",
+    "createService.noSpecs": "**{app}** não tem tipos de dependência disponíveis para provisionar aqui.",
+    "createService.pickSpec": "**{app}** — qual dependência provisionar? ({count} disponíveis)",
+    "createService.matchAmbiguous": 'Várias dependências coincidem com "{query}" — escolha uma:',
+    "createService.category": "Categoria",
+    "createService.provider": "Provider",
+    "createService.pickHint": '`application_service_create type:"<nome>"` para provisionar uma.',
+    "createService.form": "Pronto para provisionar **{spec}** para **{app}** — confirme para criar (isso cria recursos cloud reais).",
+    "createService.formHint": "confirme no painel para provisionar, ou passe `provision:true` com os parâmetros.",
+    "createService.provisioning": "Provisionando **{spec}** como **{name}** — {status}. Recursos reais estão sendo criados.",
+    "createService.reused": "**{name}** já existe ({status}) — reusando, não provisionando um segundo.",
+    "createService.provisioningHint": "`application_link_create` para linkar **{name}** a um scope — seus parâmetros de conexão aparecem após o link, no próximo deploy.",
+    // — application_link_create tool —
+    "createLink.errorLabel": "Não foi possível criar o link",
+    "createLink.noServices": "**{app}** ainda não tem serviços provisionados para linkar.",
+    "createLink.noServicesHint": "`application_service_create` para provisionar uma dependência primeiro.",
+    "createLink.pickService": "Qual serviço linkar a **{app}**?",
+    "createLink.matchAmbiguous": "Vários serviços coincidem — escolha um:",
+    "createLink.pickHint": '`application_link_create service:"<nome>"` para linkar um.',
+    "createLink.noLinkSpec": "Nenhuma link specification disponível para **{service}** nesta org.",
+    "createLink.form": "Pronto para linkar **{service}** a **{app}** — confirme para criar o link (um link de credenciais provisiona um usuário de banco de dados).",
+    "createLink.formHint": "confirme no painel para criar o link, ou passe `create:true` com os parâmetros.",
+    "createLink.linking": "Linkando **{service}** a {target} — {status}.",
+    "createLink.reused": "**{service}** já está linkado a {target} ({status}) — reusando esse link.",
+    "createLink.linkedHint": "refaça o deploy do scope para que os novos parâmetros de conexão cheguem ao runtime.",
+    // — application_service_update / application_link_update (run a custom action) —
+    "runAction.errorLabel": "Não foi possível rodar a ação",
+    "runAction.noServices": "**{app}** não tem serviços provisionados para rodar uma ação.",
+    "runAction.noServicesHint": "`application_service_create` para provisionar uma dependência primeiro.",
+    "runAction.noLinks": "**{app}** não tem links para rodar uma ação.",
+    "runAction.noLinksHint": "`application_link_create` para linkar um serviço primeiro.",
+    "runAction.pickService": "Em qual serviço rodar uma ação, em **{app}**?",
+    "runAction.serviceAmbiguous": "Vários serviços coincidem — escolha um:",
+    "runAction.pickServiceHint": '`application_service_update service:"<nome>"` para escolher um.',
+    "runAction.pickLink": "Em qual link rodar uma ação, em **{app}**?",
+    "runAction.linkAmbiguous": "Vários links coincidem — escolha um:",
+    "runAction.pickLinkHint": '`application_link_update link:"<nome>"` para escolher um.',
+    "runAction.noActions": "**{name}** não expõe ações executáveis.",
+    "runAction.pickAction": "Qual ação rodar em **{name}**?",
+    "runAction.matchAmbiguous": "Várias ações coincidem — escolha uma:",
+    "runAction.paramsHeader": "Parâmetros",
+    "runAction.pickHint": 'Passe `action:"<nome>"` para escolher uma.',
+    "runAction.form": "Pronto para rodar **{action}** em **{name}** — confirme para executar.",
+    "runAction.formHint": "confirme no painel para executar, ou passe `run:true` com os parâmetros.",
+    "runAction.running": "Rodando **{action}** em **{name}** — {status}.",
+    "runAction.ranHint": "a ação roda de forma assíncrona; seu resultado aparece quando termina.",
+    // — application_service_delete / application_link_delete (deprovision) —
+    "deleteEntity.serviceErrorLabel": "Não foi possível deletar o serviço",
+    "deleteEntity.linkErrorLabel": "Não foi possível deletar o link",
+    "deleteEntity.noServices": "**{app}** não tem serviços provisionados para deletar.",
+    "deleteEntity.noLinks": "**{app}** não tem links para deletar.",
+    "deleteEntity.pickService": "Qual serviço deletar, em **{app}**?",
+    "deleteEntity.serviceAmbiguous": "Vários serviços coincidem — escolha um:",
+    "deleteEntity.pickServiceHint": '`application_service_delete service:"<nome>"` para escolher um.',
+    "deleteEntity.pickLink": "Qual link deletar, em **{app}**?",
+    "deleteEntity.linkAmbiguous": "Vários links coincidem — escolha um:",
+    "deleteEntity.pickLinkHint": '`application_link_delete link:"<nome>"` para escolher um.',
+    "deleteEntity.hasLinks": "**{name}** ainda tem {count} link(s) ativo(s) — ficariam órfãos.",
+    "deleteEntity.hasLinksHint": "delete os links primeiro com `application_link_delete`, depois o serviço.",
+    "deleteEntity.confirm": "Pronto para deletar **{name}** e destruir seus recursos — confirme para prosseguir.",
+    "deleteEntity.confirmHint": "confirme no painel para deletar, ou passe `confirm:true`.",
+    "deleteEntity.removed": "**{name}** foi deletado.",
+    "deleteEntity.deprovisioning": "Deletando **{name}** — um agente está desprovisionando seus recursos.",
+    "deleteEntity.deprovisioningHint": "o registro é removido quando o desprovisionamento termina.",
+    // — application_parameter_delete tool —
+    "deleteParam.errorLabel": "Não foi possível deletar o parâmetro",
+    "deleteParam.absent": "**{name}** não está definido em **{app}** — nada para deletar.",
+    "deleteParam.readOnly": "**{name}** é somente leitura — um link de serviço o injeta.",
+    "deleteParam.readOnlyHint": "delete o link que o exporta com `application_link_delete`.",
+    "deleteParam.confirm": "Pronto para deletar **{name}** de **{app}** — confirme para prosseguir.",
+    "deleteParam.confirmHint": "confirme no painel para deletar, ou passe `confirm:true`.",
+    "deleteParam.deleted": "Deletei **{name}** de **{app}**.",
+    "deleteParam.deletedHint": "a mudança aplica no próximo deploy.",
+    "deleteParam.failed": "Não foi possível deletar **{name}**: {message}",
+    // — application_deployment_create tool —
+    "deploy.noScopeTypes": "Esta app ainda não tem scopes. Tipos de scope disponíveis: {types}.",
+    "deploy.createScopeHint": '`application_scope_create name:"dev" type:"{type}"`',
+    "deploy.usingRelease": "Usando a release existente **{semver}** (#{id}). ",
+    "deploy.createdRelease": "Criei a release **{semver}** a partir do build #{build}. ",
+    "deploy.createdReleaseFrom": "Criei a release **{semver}** a partir do build #{build} ({branch} @{commit}). ",
+    "deploy.noSuchVersion": "Não existe a release **{version}**{known} e não há build bem-sucedido para cortá-la.",
+    "deploy.knownVersions": " (conhecidas: {versions})",
+    "deploy.nothing": "Nada para fazer deploy: nenhuma release ativa e nenhum build bem-sucedido.",
+    "deploy.nothingHint": "faça push de um commit para o CI gerar um build, depois `application_deployment_create` de novo.",
+    "deploy.multiAsset": "O build #{build} tem vários assets — qual vai para **{scope}** ({type})?",
+    "deploy.assetHint": '`application_deployment_create asset:"{name}"`',
+    "deploy.errorLabel": "Deploy falhou",
+    "deploy.alreadyRolling": "Esta release já está em rollout em **{scope}** — mostrando esse deployment.",
+    "deploy.rejected": 'Deploy rejeitado: {message}\nIsso geralmente é a escolha do asset, não os ids — o build provavelmente tem vários assets. Tente de novo com `application_deployment_create asset:"<nome>"` (veja-os via `application_get`).',
+    // — application_deployment_update tool —
+    "traffic.sayWhat": 'Diga o que fazer: `percent:<0-100>`, `action:"finalize"` ou `action:"rollback"`.',
+    "traffic.noActive": "Nenhum rollout ativo em **{app}** — `application_deployment_create` inicia um.",
+    "traffic.several": "Vários rollouts estão ativos — passe deployment_id:",
+    "traffic.snapped": "({requested}% ajustado para {snapped}%)",
+    "traffic.errorLabel": "Ação de tráfego falhou",
+    // — application_release_create tool —
+    "createRelease.noBuilds": "Nenhum build bem-sucedido em **{app}** — faça push de um commit para o CI gerar um.",
+    "createRelease.done": "Release **{semver}** criada{from}.",
+    "createRelease.exists": "A release **{semver}** já existe para o build #{build} — reusando.",
+    "createRelease.from": " a partir do build #{build} ({branch} @{commit}, {when})",
+    "createRelease.deployHint": "`application_deployment_create release_id:{id}` para fazer o deploy.",
+    "createRelease.errorLabel": "Não foi possível criar a release",
+    // — application_parameter_create tool —
+    "setParams.created.one": "Defini 1 novo parâmetro em **{app}**: {names}.",
+    "setParams.created.many": "Defini {count} novos parâmetros em **{app}**: {names}.",
+    "setParams.updated.one": "Atualizei 1 parâmetro existente em **{app}**: {names}.",
+    "setParams.updated.many": "Atualizei {count} parâmetros existentes em **{app}**: {names}.",
+    "setParams.mixed": "Defini {total} parâmetros em **{app}** (novos: {created}, atualizados: {updated}): {names}.",
+    "setParams.applyHint": "os valores aplicam no próximo `application_deployment_create`.",
+    "setParams.scopeDimConflict": "Não dá para mirar um scope e dimensões ao mesmo tempo para `{name}` — um scope já localiza o valor. Escolha um.",
+    "setParams.partial": "A atualização de parâmetros falhou no meio: {message}\nOs parâmetros já criados permanecem — `application_parameter_list` para inspecionar.",
+    "setParams.errorLabel": "Atualização de parâmetros falhou",
+    // — application_create tool —
+    "createApp.form": "Para criar uma aplicação eu preciso de uma URL de repositório git e um nome (o formulário os coleta).\nNamespaces: {namespaces}.",
+    "createApp.noName": "Não consegui derivar um nome de {url} — passe name.",
+    "createApp.noNamespaceMatch": 'Nenhum namespace correspondente a "{namespace}". Namespaces: {names}.',
+    "createApp.noAccountMatch": 'Nenhuma conta correspondente a "{account}". Contas: {names}.',
+    "createApp.whichNamespace": "Qual namespace?",
+    "createApp.whichNamespaceFor": "Qual namespace deve conter **{name}**?",
+    "createApp.namespaceHint": '`application_create namespace:"<nome>"`',
+    "createApp.noNamespaces": "Esta organização ainda não tem namespaces — crie um no dashboard primeiro.",
+    "createApp.created": "**{name}** criada (#{id}) no namespace **{namespace}**, vinculada a {repo}.",
+    "createApp.alreadyLinked": "**{name}** (#{id}) já está vinculada a {repo} — nada para criar.",
+    "createApp.createdHint": "faça push de um commit para disparar o primeiro build, depois `application_deployment_create`.",
+    "createApp.createdHintNew": "o repo foi scaffoldado para você — clone {repo} em uma pasta, adicione seu código lá e faça push para o CI buildar, depois `application_deployment_create`.",
+    "createApp.pending": "⏳ **{name}** criada (#{id}), o provisionamento ainda está rodando (status: {status}).",
+    "createApp.pendingHint": '`application_get app:"#{id}"` para checá-la.',
+    "createApp.errorLabel": "Não foi possível criar a aplicação",
+    // — playbook_get tool —
+    "playbook.errorLabel": "Não foi possível carregar o playbook",
+    // — application_scope_create tool —
+    "createScope.whichType": "Qual tipo de scope para **{name}**?",
+    "createScope.typeHint": '`application_scope_create name:"{name}" type:"<tipo>"`',
+    "createScope.noTypes": 'Nenhum tipo de scope disponível — passe type explicitamente (ex. type:"web_pool").',
+    "createScope.provisioning": "⏳ O scope **{name}** (#{id}, {type}{dimensions}) está provisionando — a infraestrutura está sendo criada.",
+    "createScope.exists": "O scope **{name}** (#{id}) já existe ({status}) — nada para criar.",
+    "createScope.provisioningHint": '`application_get` o mostra; quando ativo, `application_deployment_create scope:"{name}"`.',
+    "createScope.errorLabel": "Não foi possível criar o scope",
+    // — auth & transport —
+    "error.credentialRejected": "nullplatform rejeitou a credencial ({status}) — verifique sua NP_API_KEY",
+    "error.permission": "seu usuário nullplatform não tem permissão para esta ação (403)",
+    "error.bearerNoOrg": "o bearer não é um token emitido pela nullplatform (sem claim de organização)",
+    "http.authRequired": "autenticação necessária",
+    "http.authHint": "envie sua própria credencial nullplatform: `Authorization: Bearer <NP_API_KEY>` (ou X-NP-API-Key)",
+    "http.originDenied": "origem não permitida",
+    "http.bodyTooLarge": "corpo da requisição muito grande",
+    "http.invalidJson": "corpo JSON inválido",
+    "http.verifyUnavailable": "não foi possível verificar a credencial com a nullplatform",
+    "http.rateLimited": "requisições demais — diminua o ritmo",
+    // — prompts (inserted as the user's message) —
+    "prompt.ship": `Faça o deploy do código mais recente de {app}{scope}.
+1. Rode o status primeiro e me diga o que vai ser publicado (build/release).
+2. faça o deploy.
+3. Aumente o tráfego em etapas — 25%, depois 50%, depois 100% — checando o status entre as etapas; pare e me avise se algo parecer não saudável.
+4. Quando 100% estiver saudável, finalize e confirme com um status final.`,
+    "prompt.ship.toScope": ' para o scope "{scope}"',
+    "prompt.thisRepoApp": "a aplicação vinculada a este repositório",
+    "prompt.setup": `Conecte este repositório à nullplatform:
+1. Rode application_get — se o repositório já estiver vinculado a uma aplicação, apenas me mostre onde estou.
+2. Se não estiver vinculado, verifique application_list por uma app com o nome deste repositório antes de criar qualquer coisa.
+3. Se nenhuma existir, application_create para vinculá-lo, depois mostre application_get e me diga o que acontece a seguir (primeiro build via CI, depois deploy).`,
+    "prompt.health": `Me dê um health check de {app}:
+1. status — o que está no ar e onde, algo em rollout?
+2. métricas (janela de 3h) — aponte qualquer coisa incomum em throughput, tempo de resposta, taxa de erro, CPU ou memória.
+3. logs — escaneie as linhas recentes por erros ou avisos.
+Termine com um veredito de um parágrafo: saudável / degradado / com problemas, e a única ação seguinte mais útil.`,
+    "prompt.rollback": `Algo está errado — reverta {app} agora mesmo: encontre seu rollout ativo, rode application_deployment_update action:"rollback", depois confirme com application_get que a versão anterior está atendendo o tráfego e resuma o que foi revertido.`,
+};
+const catalogs = { en: english, es: spanish, pt: portuguese };
+const SUPPORTED = ["en", "es", "pt"];
 let defaultLocale = "en";
 const localeScope = new AsyncLocalStorage();
 /** Process-wide default (stdio: from NP_LANG/LANG at startup). */
@@ -591,6 +1163,9 @@ const LANGUAGE_NAMES = {
     español: "es",
     espanol: "es",
     castellano: "es",
+    portuguese: "pt",
+    português: "pt",
+    portugues: "pt",
 };
 /** "es-AR, en;q=0.9" / "es_AR.UTF-8" / "es" / "Spanish" -> a supported locale, or undefined. */
 export function matchLocale(input) {