@nullplatform/mcp 0.1.7 → 0.1.9

package/dist/i18n.js

@@ -340,6 +340,7 @@ const english = {
     "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>"`',
@@ -347,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",
@@ -704,6 +706,7 @@ const spanish = {
     "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>"`',
@@ -711,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",
@@ -751,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). */
@@ -775,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) {

package/dist/tools/create-app.js

@@ -48,6 +48,10 @@ export const createAppTool = defineTool({
     errorKey: "createApp.errorLabel",
     inputSchema: {
         name: z.string().optional().describe("App name (default: the repo name)"),
+        account: z
+            .string()
+            .optional()
+            .describe("Account name to place the app under — narrows the namespace choice to that account (a namespace name can repeat across accounts). Pick the best-fitting account from context when it isn't given."),
         namespace: z.string().optional().describe("Namespace name (prefer namespace_id when known)"),
         namespace_id: z.number().optional().describe("Namespace id to create the app in"),
         repository_url: z
@@ -104,26 +108,39 @@ export const createAppTool = defineTool({
                 ?.replace(/\.git$/, "");
         if (!name)
             return fail(translate("createApp.noName", { url: repoUrl }));
-        // Resolve the target namespace. If it can't be pinned down and there's a real choice, fall
-        // back to the form (rendered as a picker in the widget) rather than a dead-end ask.
+        // Resolve where the app lives — an (account, namespace) pair. Narrow to the named account first
+        // (a namespace name can repeat across accounts), then match/auto-pick the namespace inside it.
+        // If it still can't be pinned down and there's a real choice, fall back to the form (a picker)
+        // rather than a dead-end ask.
         const skeleton = await context.org.getSkeleton();
+        const accountQuery = args.account?.toLowerCase();
+        const candidates = accountQuery
+            ? skeleton.namespaces.filter((candidate) => (candidate.account_name ?? "").toLowerCase().includes(accountQuery))
+            : skeleton.namespaces;
+        if (accountQuery && candidates.length === 0) {
+            const accounts = [
+                ...new Set(skeleton.namespaces.map((candidate) => candidate.account_name).filter(Boolean)),
+            ];
+            return fail(translate("createApp.noAccountMatch", { account: args.account ?? "", names: accounts.join(", ") }));
+        }
         let namespace = args.namespace_id
-            ? skeleton.namespaces.find((candidate) => candidate.id === args.namespace_id)
+            ? candidates.find((candidate) => candidate.id === args.namespace_id)
             : undefined;
         if (!namespace && args.namespace) {
             const query = args.namespace.toLowerCase();
-            const matches = skeleton.namespaces.filter((candidate) => candidate.name.toLowerCase().includes(query));
+            const matches = candidates.filter((candidate) => candidate.name.toLowerCase().includes(query));
             if (matches.length === 1)
                 namespace = matches[0];
             else if (matches.length === 0) {
                 return fail(translate("createApp.noNamespaceMatch", {
                     namespace: args.namespace,
-                    names: skeleton.namespaces.map((candidate) => candidate.name).join(", "),
+                    names: candidates.map((candidate) => candidate.name).join(", "),
                 }));
             }
         }
-        if (!namespace && skeleton.namespaces.length === 1)
-            namespace = skeleton.namespaces[0];
+        // One namespace in scope (the whole org, or the chosen account) → auto-pick it.
+        if (!namespace && candidates.length === 1)
+            namespace = candidates[0];
         if (!namespace) {
             if (skeleton.namespaces.length === 0)
                 return fail(translate("createApp.noNamespaces"));
@@ -174,10 +191,21 @@ export const createAppTool = defineTool({
             .slice(-3)
             .map((entry) => `- ${entry.message ?? JSON.stringify(entry)}`)
             .join("\n");
-        const structured = { application: { id: app.id, name, status: app.status, nrn: app.nrn } };
+        // A new repo scaffolded from a template is a fresh REMOTE repo the developer has never cloned —
+        // the next move is to pull it into a folder and build there. An import is already local, so its
+        // next move is just to push. The two paths get different guidance.
+        const scaffolded = args.template_id !== undefined;
+        const structured = {
+            application: { id: app.id, name, status: app.status, nrn: app.nrn },
+            scaffolded,
+            repository_url: repoUrl,
+        };
+        const createdHint = scaffolded
+            ? translate("createApp.createdHintNew", { repo: repoUrl })
+            : translate("createApp.createdHint");
         if (app.status === "active") {
             return reply(`${glyph("active")} ${translate("createApp.created", { name, id: app.id, namespace: namespace.name, repo: repoUrl })}${recentMessages ? `\n${recentMessages}` : ""}` +
-                next(translate("createApp.createdHint")) +
+                next(createdHint) +
                 dashboard, structured);
         }
         return reply(`${translate("createApp.pending", { name, id: app.id, status: app.status })}${recentMessages ? `\n${recentMessages}` : ""}` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nullplatform/mcp",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "nullplatform from your code assistant — an MCP server that replaces the dashboard for the everyday developer journey",
   "license": "MIT",
   "author": "nullplatform",

package/skills/starting-a-new-app/SKILL.md

@@ -13,11 +13,19 @@ platform you haven't proven yet.
 
 ## 1. Place it before you create it
 
-`application_create` opens a pre-filled form — but *where* it goes is a real decision, not a
-default. Read the request for the home it implies (a demo for a banking client in Argentina is not
-the same namespace as a throwaway): list the namespaces the form offers and pick the account +
-namespace that fits, and confirm that choice for anything that isn't obviously disposable. New repo
-vs. importing an existing one is the other fork the form covers; it derives the repo URL for new ones.
+An app lives in an **account + namespace** pair — `application_create` opens a pre-filled form, but
+*where* it goes is a real decision, not a default. Read the request for the home it implies (a demo
+for a banking client in Argentina is not the same namespace as a throwaway) and pick the best-fitting
+pair from that context rather than the first on the list; pass `account` to disambiguate when a
+namespace name repeats across accounts, and `namespace`/`namespace_id` for the namespace. Confirm the
+choice for anything that isn't obviously disposable, and never drop it in the default namespace
+without checking it fits. New repo vs. importing an existing one is the other fork the form covers;
+it derives the repo URL for new ones.
+
+For a **new** repo the form also offers scaffolding **templates** — read them and pick the best fit
+for the stack (a React/SPA template for a UI, a Node/Express template for an API). If none fits
+cleanly, say so and offer the closest, or fall back to importing an existing repo — don't force a
+mismatched template. (Importing skips the template entirely: you bring a repo you already have.)
 
 A request often implies **more than one app** (a frontend *and* its API). Create them one at a time
 in the same namespace, named so the pair reads as a set — there is no batch-create, and that's fine:
@@ -45,10 +53,15 @@ Once a service is linked, its connection details arrive **automatically as read-
 hard-code them or re-create them by hand. New parameters only reach a running scope on the **next
 deploy**.
 
-## 4. Hand off to the build
+## 4. Pull the repo, then build
 
-The platform's job is done when the app exists, runs, and its dependencies are wired and surfaced as
-parameters. Writing the REST API, the UI, the schema or its codegen — that is your craft, not this
+A new-from-template app is a fresh **remote** repo you've never cloned — so the move is forward, not
+backwards: **clone it into a folder and continue the work there**, rather than writing code first and
+retrofitting it onto the platform. (An imported app is already local; nothing to clone.) The create
+reply carries the repo URL; clone it, and if the request implied a pair (a frontend *and* its API),
+clone each into its own folder.
+
+Then the code is your own craft — writing the REST API, the UI, the schema or its codegen is not this
 playbook's job (same boundary as `working-from-a-ticket`). Build against the injected env vars, keep
 the work on a branch with the issue key (`tracing-a-change`), push so CI produces a build, and ship
 it with `deploying-safely`.