@nullplatform/mcp 0.1.0

package/dist/i18n.js

@@ -0,0 +1,595 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * i18n for everything user-facing: tool reply markdown, ask-backs, error messages,
+ * prompt bodies and HTTP error hints. Model-facing text (tool names, descriptions,
+ * schema descriptions, skills) deliberately stays English — it is prompt material.
+ *
+ * Locale: stdio reads NP_LANG/LANG once at startup; HTTP resolves Accept-Language per
+ * request and scopes it with AsyncLocalStorage. Adding a locale = adding one catalog
+ * object below — completeness is compile-checked against the English catalog.
+ */
+const english = {
+    // — resolution (which app?) —
+    "resolve.ambiguous": "Several applications match — say which one (name or `#id`):",
+    "resolve.noId": "No application with id {id}.",
+    "resolve.noMatch": 'No application matching "{ref}".',
+    "resolve.repoUnlinked": 'This repo ({url}) isn\'t linked to any nullplatform application. Pass app:"<name>" or run application_create to link it.',
+    "resolve.noInput": 'No app given and no git remote found in the workspace. Pass app:"<name>" (or an id like "#123").',
+    "resolve.noNrn": "Can't resolve the application NRN for **{app}**.",
+    // — scope selection —
+    "scope.which": "Which scope?",
+    "scope.none": "This app has no scopes yet.",
+    "scope.noneHint": '`application_scope_create name:"dev"` first — then `application_deployment_create`.',
+    "scope.noMatch": 'No scope matching "{wanted}". Scopes: {names}.',
+    "scope.noMatchDetailed": 'No scope matching "{wanted}" (by name or dimension). Scopes:',
+    "scope.createHint": '`application_scope_create name:"{name}"` to create it.',
+    "scope.deployHint": '`application_deployment_create scope:"<name or dimension, e.g. environment=production>"`',
+    "scope.perScope": "{noun} are per scope — which one?",
+    "scope.readHint": '`{tool} scope:"{name}"`',
+    // — table headers —
+    "header.app": "App",
+    "header.id": "Id",
+    "header.namespace": "Namespace",
+    "header.account": "Account",
+    "header.status": "Status",
+    "header.scope": "Scope",
+    "header.dimensions": "Dimensions",
+    "header.name": "Name",
+    "header.variable": "Variable",
+    "header.type": "Type",
+    "header.secret": "Secret",
+    "header.value": "Value",
+    "header.metric": "Metric",
+    "header.now": "Now",
+    "header.avg": "Avg",
+    "header.max": "Max",
+    "header.trend": "Trend",
+    "header.asset": "Asset",
+    "header.platform": "Platform",
+    "header.deployment": "Deployment",
+    "header.provider": "Provider",
+    "header.live": "Live",
+    "header.traffic": "Traffic",
+    "header.when": "When",
+    // — markdown design language —
+    "md.next": "Next",
+    "md.none": "_none_",
+    "md.justNow": "just now",
+    "md.minutesAgo": "{count}m ago",
+    "md.hoursAgo": "{count}h ago",
+    "md.daysAgo": "{count}d ago",
+    "md.dashboard": "dashboard",
+    "md.unknown": "unknown",
+    // — platform status words (fallback: raw status with underscores spaced) —
+    "status.active": "active",
+    "status.successful": "successful",
+    "status.finalized": "finalized",
+    "status.running": "running",
+    "status.pending": "pending",
+    "status.creating": "creating",
+    "status.updating": "updating",
+    "status.building": "building",
+    "status.waiting_for_instances": "waiting for instances",
+    "status.switching_traffic": "switching traffic",
+    "status.finalizing": "finalizing",
+    "status.cancelling": "cancelling",
+    "status.rolling_back": "rolling back",
+    "status.creating_approval": "waiting for approval",
+    "status.failed": "failed",
+    "status.cancelled": "cancelled",
+    "status.rolled_back": "rolled back",
+    "status.deleted": "deleted",
+    "status.inactive": "inactive",
+    "status.creating_approval_denied": "approval denied",
+    // — status view —
+    "render.noScopes": "_No scopes yet — nothing to deploy onto._",
+    "render.nothingDeployed": "_nothing deployed_",
+    "render.noBuilds": "_none — push to CI_",
+    "render.latestBuild": "Latest build",
+    "render.releases": "Releases",
+    "render.liveOn": "live on {scopes}",
+    "render.deployment": "**Deployment**",
+    "render.deploying": "🚀 **Deploying**",
+    "render.release": "Release",
+    "render.started": "started {when}",
+    "render.now": "now",
+    "render.desired": "→ desired {pct}%",
+    // — next-step hints (status) —
+    "hint.rolloutTraffic": 'deployment #{id} on **{scope}** is at {traffic}% traffic — `application_deployment_update percent:<n>` to advance, `application_deployment_update action:"finalize"` when done, `application_deployment_update action:"rollback"` to back out.',
+    "hint.rolloutStatus": "deployment #{id} on **{scope}** is {status} — `application_get deployment:{id}` to watch.",
+    "hint.noScopes": 'no scopes yet — `application_scope_create name:"dev"` to get a place to deploy.',
+    "hint.buildNewer": "build #{id} ({branch} @{commit}) is newer than release {semver} — `application_deployment_create` ships it (creates the release for you).",
+    "hint.buildUnreleased": "build #{id} has no release yet — `application_deployment_create` ships it (creates the release for you).",
+    "hint.releaseNotLive": "release {semver} isn't live yet — `application_deployment_create` to ship it.",
+    "hint.noBuilds": "no builds yet — push a commit so CI produces one, then `application_deployment_create`.",
+    "hint.upToDate": "everything is up to date ✅",
+    "hint.watch": "`application_get deployment:{id}` to watch.",
+    // — next-step hints (rollout) —
+    "rollout.full": 'all traffic on the new version — `application_deployment_update action:"finalize"` to retire the old one.',
+    "rollout.moving": "traffic moving {from}% → {to}% — `application_get deployment:{id}` to watch.",
+    "rollout.at": 'traffic at {traffic}% — `application_deployment_update percent:<n>` to advance (marks: 1,5,10,25,50,75,90,95,99,100), `application_deployment_update action:"rollback"` to back out.',
+    "rollout.instances": "instances are coming up — `application_get deployment:{id}` to watch.",
+    "rollout.switching": "traffic is switching — `application_get deployment:{id}` to watch.",
+    "rollout.finalizing": "finalizing — old instances are being retired.",
+    "rollout.done": "done — the release is fully live ✅",
+    "rollout.approval": "waiting for an approval ✋ — an approver must allow this deployment (dashboard → Approvals).",
+    "rollout.failed": 'deployment failed — `application_log_list` for output, `application_deployment_update action:"rollback"` if traffic moved.',
+    "rollout.rolledBack": "rolled back — previous version is serving all traffic.",
+    // — application_get tool —
+    "status.errorLabel": "Couldn't load status",
+    // — application_list tool —
+    "findApps.noneMatching": "No applications{matching}{inNamespace}.",
+    "findApps.matching": ' matching "{query}"',
+    "findApps.inNamespace": ' in namespaces ~"{namespace}"',
+    "findApps.createHint": "`application_create` links this repo as a new application.",
+    "findApps.count.one": "1 application",
+    "findApps.count.many": "{count} applications",
+    "findApps.statusHint": '`application_get app:"<name>"` for the full picture of one.',
+    "findApps.truncated": "Showing the first {shown} — narrow with a query or namespace to see the rest.",
+    "findApps.errorLabel": "Search failed",
+    // — application_parameter_list tool —
+    "params.unavailable": "Parameter listing isn't available here. `application_parameter_create` still works.",
+    "params.viewInDashboard": "view in dashboard",
+    "params.none": "**{app}** has no parameters.",
+    "params.noneHint": "`application_parameter_create` to add env vars or files.",
+    "params.count.one": "**{app}** · 1 parameter",
+    "params.count.many": "**{app}** · {count} parameters",
+    "params.unset": "_unset_",
+    "params.applyHint": "changed values apply on the next `application_deployment_create`.",
+    "params.errorLabel": "Couldn't list parameters",
+    // — application_log_list tool —
+    "logs.noun": "Logs",
+    "logs.noScopes": "**{app}** has no scopes, so there are no runtime logs yet.",
+    "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.errorLabel": "Couldn't read logs",
+    "logs.errorSuffix": "The dashboard's Logs view may still have them.",
+    // — application_metric_list tool —
+    "metrics.noun": "Metrics",
+    "metrics.noScopes": "**{app}** has no scopes, so there are no runtime metrics yet.",
+    "metrics.noScopesHint": "`application_deployment_create` after creating a scope.",
+    "metrics.empty": "No metric datapoints for **{app}** · {scope} in the last {window} — the scope may be young or the metrics agent not wired.",
+    "metrics.openInDashboard": "performance in dashboard",
+    "metrics.title": "**{app}** · {scope} — last {window}",
+    "metrics.errorLabel": "Couldn't load metrics",
+    // — application_build_list tool —
+    "builds.title": "**{app}** · {count} recent build(s)",
+    "builds.branch": "Branch",
+    "builds.commit": "Commit",
+    "builds.released": "Released",
+    "builds.none": "**{app}** has no builds yet.",
+    "builds.noneHint": "push a commit so CI produces one, then `application_deployment_create`.",
+    "builds.deployHint": "`application_deployment_create build_id:{build}` ships it (cuts the release for you).",
+    "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.errorLabel": "Couldn't list builds",
+    // — organization_get tool —
+    "overview.title": "Organization overview · {count} application(s) scanned",
+    "overview.truncated": '_(showing the first {count} — narrow with `organization_get query:"..."`)_',
+    "overview.activeRollouts": "Active rollouts ({count})",
+    "overview.trouble": "Needs attention ({count})",
+    "overview.hintActive": '`application_get app:"{app}"` to watch a rollout, or `application_deployment_update` to drive one.',
+    "overview.hintTrouble": '`application_log_list app:"{app}"` to investigate, `application_deployment_update action:"rollback"` if needed.',
+    "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.action": "Action",
+    "approvals.entity": "Entity",
+    "approvals.requestedBy": "Requested by",
+    "approvals.none": "No pending approvals for **{app}**.",
+    "approvals.needId": "Pass `approval_id` together with the action.",
+    "approvals.invalidId": "That doesn't look like a valid approval id — copy it from the `application_approval_list` list.",
+    "approvals.approved": "Approved {id} — the gated action can proceed.",
+    "approvals.cancelled": "Cancelled approval {id}.",
+    "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.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_deployment_create tool —
+    "deploy.noScopeTypes": "This app has no scopes yet. Available scope types: {types}.",
+    "deploy.createScopeHint": '`application_scope_create name:"dev" type:"{type}"`',
+    "deploy.usingRelease": "Using existing release **{semver}** (#{id}). ",
+    "deploy.createdRelease": "Created release **{semver}** from build #{build}. ",
+    "deploy.createdReleaseFrom": "Created release **{semver}** from build #{build} ({branch} @{commit}). ",
+    "deploy.noSuchVersion": "No release **{version}** exists{known} and there's no successful build to cut it from.",
+    "deploy.knownVersions": " (known: {versions})",
+    "deploy.nothing": "Nothing to deploy: no active releases and no successful builds.",
+    "deploy.nothingHint": "push a commit so CI produces a build, then `application_deployment_create` again.",
+    "deploy.multiAsset": "Build #{build} has several assets — which one ships to **{scope}** ({type})?",
+    "deploy.assetHint": '`application_deployment_create asset:"{name}"`',
+    "deploy.errorLabel": "Deploy failed",
+    "deploy.alreadyRolling": "This release is already rolling out on **{scope}** — showing that deployment.",
+    "deploy.rejected": 'Deploy rejected: {message}\nThis usually means the asset choice, not the ids — the build likely has several assets. Retry with `application_deployment_create asset:"<name>"` (see them via `application_get`).',
+    // — application_deployment_update tool —
+    "traffic.sayWhat": 'Say what to do: `percent:<0-100>`, `action:"finalize"` or `action:"rollback"`.',
+    "traffic.noActive": "No active rollout on **{app}** — `application_deployment_create` starts one.",
+    "traffic.several": "Several rollouts are active — pass deployment_id:",
+    "traffic.snapped": "({requested}% snapped to {snapped}%)",
+    "traffic.errorLabel": "Traffic action failed",
+    // — application_release_create tool —
+    "createRelease.noBuilds": "No successful builds on **{app}** — push a commit so CI produces one.",
+    "createRelease.done": "Release **{semver}** created{from}.",
+    "createRelease.exists": "Release **{semver}** already exists for build #{build} — reusing it.",
+    "createRelease.from": " from build #{build} ({branch} @{commit}, {when})",
+    "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.applyHint": "values apply on the next `application_deployment_create`.",
+    "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.whichNamespace": "Which namespace?",
+    "createApp.whichNamespaceFor": "Which namespace should own **{name}**?",
+    "createApp.namespaceHint": '`application_create namespace:"<name>"`',
+    "createApp.noNamespaces": "This organization has no namespaces yet — create one in the dashboard first.",
+    "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.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",
+    // — playbook_get tool —
+    "playbook.errorLabel": "Couldn't load the playbook",
+    // — application_scope_create tool —
+    "createScope.whichType": "Which scope type for **{name}**?",
+    "createScope.typeHint": '`application_scope_create name:"{name}" type:"<type>"`',
+    "createScope.noTypes": 'No scope types available — pass type explicitly (e.g. type:"web_pool").',
+    "createScope.provisioning": "⏳ Scope **{name}** (#{id}, {type}{dimensions}) is provisioning — infrastructure is being created.",
+    "createScope.exists": "Scope **{name}** (#{id}) already exists ({status}) — nothing to create.",
+    "createScope.provisioningHint": '`application_get` shows it; once active, `application_deployment_create scope:"{name}"`.',
+    "createScope.errorLabel": "Couldn't create scope",
+    // — auth & transport —
+    "error.credentialRejected": "nullplatform rejected the credential ({status}) — check your NP_API_KEY",
+    "error.permission": "your nullplatform user doesn't have permission for this action (403)",
+    "error.bearerNoOrg": "the bearer is not a nullplatform-issued token (no organization claim)",
+    "http.authRequired": "authentication required",
+    "http.authHint": "send your own nullplatform credential: `Authorization: Bearer <NP_API_KEY>` (or X-NP-API-Key)",
+    "http.originDenied": "origin not allowed",
+    "http.bodyTooLarge": "request body too large",
+    "http.invalidJson": "invalid JSON body",
+    "http.verifyUnavailable": "could not verify the credential with nullplatform",
+    "http.rateLimited": "too many requests — slow down",
+    // — prompts (inserted as the user's message) —
+    "prompt.ship": `Ship the latest code of {app}{scope}.
+1. Run status first and tell me what will ship (build/release).
+2. deploy it.
+3. Walk traffic up in steps — 25%, then 50%, then 100% — checking status between steps; stop and tell me if anything looks unhealthy.
+4. When 100% is healthy, finalize and confirm with a final status.`,
+    "prompt.ship.toScope": ' to the "{scope}" scope',
+    "prompt.thisRepoApp": "the application linked to this repo",
+    "prompt.setup": `Connect this repository to nullplatform:
+1. Run application_get — if the repo is already linked to an application, just show me where I stand.
+2. If it isn't linked, check application_list for an app matching this repo's name before creating anything.
+3. If none exists, application_create to link it, then show application_get and tell me what happens next (first build via CI, then deploy).`,
+    "prompt.health": `Give me a health check of {app}:
+1. status — what's live where, anything mid-rollout?
+2. metrics (3h window) — call out anything unusual in throughput, response time, error rate, CPU or memory.
+3. logs — scan the recent lines for errors or warnings.
+Finish with a one-paragraph verdict: healthy / degraded / in trouble, and the single most useful next action.`,
+    "prompt.rollback": `Something is wrong — roll back {app} right now: find its active rollout, run application_deployment_update action:"rollback", then confirm with application_get that the previous version is serving traffic and summarize what was rolled back.`,
+};
+const spanish = {
+    "resolve.ambiguous": "Varias aplicaciones coinciden — decime cuál (nombre o `#id`):",
+    "resolve.noId": "No hay ninguna aplicación con id {id}.",
+    "resolve.noMatch": 'No hay ninguna aplicación que coincida con "{ref}".',
+    "resolve.repoUnlinked": 'Este repo ({url}) no está vinculado a ninguna aplicación de nullplatform. Pasá app:"<nombre>" o ejecutá application_create para vincularlo.',
+    "resolve.noInput": 'No se indicó app y no hay git remote en el workspace. Pasá app:"<nombre>" (o un id como "#123").',
+    "resolve.noNrn": "No puedo resolver el NRN de la aplicación **{app}**.",
+    "scope.which": "¿Qué scope?",
+    "scope.none": "Esta app todavía no tiene scopes.",
+    "scope.noneHint": '`application_scope_create name:"dev"` primero — después `application_deployment_create`.',
+    "scope.noMatch": 'Ningún scope coincide con "{wanted}". Scopes: {names}.',
+    "scope.noMatchDetailed": 'Ningún scope coincide con "{wanted}" (por nombre o dimensión). Scopes:',
+    "scope.createHint": '`application_scope_create name:"{name}"` para crearlo.',
+    "scope.deployHint": '`application_deployment_create scope:"<nombre o dimensión, p. ej. environment=production>"`',
+    "scope.perScope": "{noun} son por scope — ¿cuál?",
+    "scope.readHint": '`{tool} scope:"{name}"`',
+    "header.app": "App",
+    "header.id": "Id",
+    "header.namespace": "Namespace",
+    "header.account": "Cuenta",
+    "header.status": "Estado",
+    "header.scope": "Scope",
+    "header.dimensions": "Dimensiones",
+    "header.name": "Nombre",
+    "header.variable": "Variable",
+    "header.type": "Tipo",
+    "header.secret": "Secreto",
+    "header.value": "Valor",
+    "header.metric": "Métrica",
+    "header.now": "Ahora",
+    "header.avg": "Prom",
+    "header.max": "Máx",
+    "header.trend": "Tendencia",
+    "header.asset": "Asset",
+    "header.platform": "Plataforma",
+    "header.deployment": "Deployment",
+    "header.provider": "Proveedor",
+    "header.live": "En vivo",
+    "header.traffic": "Tráfico",
+    "header.when": "Cuándo",
+    "md.next": "Siguiente",
+    "md.none": "_ninguno_",
+    "md.justNow": "recién",
+    "md.minutesAgo": "hace {count}m",
+    "md.hoursAgo": "hace {count}h",
+    "md.daysAgo": "hace {count}d",
+    "md.dashboard": "dashboard",
+    "md.unknown": "desconocido",
+    "status.active": "activo",
+    "status.successful": "exitoso",
+    "status.finalized": "finalizado",
+    "status.running": "corriendo",
+    "status.pending": "pendiente",
+    "status.creating": "creando",
+    "status.updating": "actualizando",
+    "status.building": "compilando",
+    "status.waiting_for_instances": "esperando instancias",
+    "status.switching_traffic": "moviendo tráfico",
+    "status.finalizing": "finalizando",
+    "status.cancelling": "cancelando",
+    "status.rolling_back": "revirtiendo",
+    "status.creating_approval": "esperando aprobación",
+    "status.failed": "falló",
+    "status.cancelled": "cancelado",
+    "status.rolled_back": "revertido",
+    "status.deleted": "eliminado",
+    "status.inactive": "inactivo",
+    "status.creating_approval_denied": "aprobación denegada",
+    "render.noScopes": "_Sin scopes todavía — no hay dónde deployar._",
+    "render.nothingDeployed": "_nada deployado_",
+    "render.noBuilds": "_ninguno — pusheá para que CI compile_",
+    "render.latestBuild": "Último build",
+    "render.releases": "Releases",
+    "render.liveOn": "en vivo en {scopes}",
+    "render.deployment": "**Deployment**",
+    "render.deploying": "🚀 **Deployando**",
+    "render.release": "Release",
+    "render.started": "empezó {when}",
+    "render.now": "ahora",
+    "render.desired": "→ deseado {pct}%",
+    "hint.rolloutTraffic": 'el deployment #{id} en **{scope}** está al {traffic}% de tráfico — `application_deployment_update percent:<n>` para avanzar, `application_deployment_update action:"finalize"` al terminar, `application_deployment_update action:"rollback"` para volver atrás.',
+    "hint.rolloutStatus": "el deployment #{id} en **{scope}** está {status} — `application_get deployment:{id}` para seguirlo.",
+    "hint.noScopes": 'sin scopes todavía — `application_scope_create name:"dev"` para tener dónde deployar.',
+    "hint.buildNewer": "el build #{id} ({branch} @{commit}) es más nuevo que la release {semver} — `application_deployment_create` lo publica (crea la release por vos).",
+    "hint.buildUnreleased": "el build #{id} no tiene release — `application_deployment_create` lo publica (crea la release por vos).",
+    "hint.releaseNotLive": "la release {semver} no está en vivo — `application_deployment_create` para publicarla.",
+    "hint.noBuilds": "sin builds todavía — pusheá un commit para que CI genere uno, después `application_deployment_create`.",
+    "hint.upToDate": "todo está al día ✅",
+    "hint.watch": "`application_get deployment:{id}` para seguirlo.",
+    "rollout.full": 'todo el tráfico en la versión nueva — `application_deployment_update action:"finalize"` para retirar la vieja.',
+    "rollout.moving": "el tráfico va de {from}% → {to}% — `application_get deployment:{id}` para seguirlo.",
+    "rollout.at": 'tráfico al {traffic}% — `application_deployment_update percent:<n>` para avanzar (marcas: 1,5,10,25,50,75,90,95,99,100), `application_deployment_update action:"rollback"` para volver atrás.',
+    "rollout.instances": "las instancias están levantando — `application_get deployment:{id}` para seguirlo.",
+    "rollout.switching": "el tráfico se está moviendo — `application_get deployment:{id}` para seguirlo.",
+    "rollout.finalizing": "finalizando — se están retirando las instancias viejas.",
+    "rollout.done": "listo — la release está completamente en vivo ✅",
+    "rollout.approval": "esperando una aprobación ✋ — alguien tiene que aprobar este deployment (dashboard → Approvals).",
+    "rollout.failed": 'el deployment falló — `application_log_list` para ver la salida, `application_deployment_update action:"rollback"` si se movió tráfico.',
+    "rollout.rolledBack": "revertido — la versión anterior está sirviendo todo el tráfico.",
+    "status.errorLabel": "No pude cargar el estado",
+    "findApps.noneMatching": "No hay aplicaciones{matching}{inNamespace}.",
+    "findApps.matching": ' que coincidan con "{query}"',
+    "findApps.inNamespace": ' en namespaces ~"{namespace}"',
+    "findApps.createHint": "`application_create` vincula este repo como una aplicación nueva.",
+    "findApps.count.one": "1 aplicación",
+    "findApps.count.many": "{count} aplicaciones",
+    "findApps.statusHint": '`application_get app:"<nombre>"` para ver el panorama completo de una.',
+    "findApps.truncated": "Mostrando las primeras {shown} — afiná con una búsqueda o namespace para ver el resto.",
+    "findApps.errorLabel": "Falló la búsqueda",
+    "params.unavailable": "El listado de parámetros no está disponible acá. `application_parameter_create` igual funciona.",
+    "params.viewInDashboard": "ver en el dashboard",
+    "params.none": "**{app}** no tiene parámetros.",
+    "params.noneHint": "`application_parameter_create` para agregar variables de entorno o archivos.",
+    "params.count.one": "**{app}** · 1 parámetro",
+    "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.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.errorLabel": "No pude leer los logs",
+    "logs.errorSuffix": "La vista Logs del dashboard puede tenerlos igual.",
+    "metrics.noun": "Las métricas",
+    "metrics.noScopes": "**{app}** no tiene scopes, así que todavía no hay métricas de runtime.",
+    "metrics.noScopesHint": "`application_deployment_create` después de crear un scope.",
+    "metrics.empty": "No hay datapoints de métricas para **{app}** · {scope} en las últimas {window} — el scope puede ser muy nuevo o el agente de métricas no estar conectado.",
+    "metrics.openInDashboard": "performance en el dashboard",
+    "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.branch": "Branch",
+    "builds.commit": "Commit",
+    "builds.released": "Released",
+    "builds.none": "**{app}** todavía no tiene builds.",
+    "builds.noneHint": "pusheá un commit para que CI genere uno, después `application_deployment_create`.",
+    "builds.deployHint": "`application_deployment_create build_id:{build}` lo publica (crea la release por vos).",
+    "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.errorLabel": "No pude listar los builds",
+    // — organization_get tool —
+    "overview.title": "Panorama de la organización · {count} aplicación(es) escaneada(s)",
+    "overview.truncated": '_(muestro las primeras {count} — acotá con `organization_get query:"..."`)_',
+    "overview.activeRollouts": "Rollouts activos ({count})",
+    "overview.trouble": "Requiere atención ({count})",
+    "overview.hintActive": '`application_get app:"{app}"` para seguir un rollout, o `application_deployment_update` para manejarlo.',
+    "overview.hintTrouble": '`application_log_list app:"{app}"` para investigar, `application_deployment_update action:"rollback"` si hace falta.',
+    "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.action": "Acción",
+    "approvals.entity": "Entidad",
+    "approvals.requestedBy": "Solicitada por",
+    "approvals.none": "No hay aprobaciones pendientes para **{app}**.",
+    "approvals.needId": "Pasá `approval_id` junto con la acción.",
+    "approvals.invalidId": "Eso no parece un approval id válido — copialo de la lista de `application_approval_list`.",
+    "approvals.approved": "Aprobé {id} — la acción bloqueada puede continuar.",
+    "approvals.cancelled": "Cancelé la aprobación {id}.",
+    "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.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",
+    "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}). ",
+    "deploy.createdRelease": "Creé la release **{semver}** desde el build #{build}. ",
+    "deploy.createdReleaseFrom": "Creé la release **{semver}** desde el build #{build} ({branch} @{commit}). ",
+    "deploy.noSuchVersion": "No existe la release **{version}**{known} y no hay un build exitoso del cual cortarla.",
+    "deploy.knownVersions": " (conocidas: {versions})",
+    "deploy.nothing": "Nada para deployar: no hay releases activas ni builds exitosos.",
+    "deploy.nothingHint": "pusheá un commit para que CI genere un build y después `application_deployment_create` de nuevo.",
+    "deploy.multiAsset": "El build #{build} tiene varios assets — ¿cuál va a **{scope}** ({type})?",
+    "deploy.assetHint": '`application_deployment_create asset:"{name}"`',
+    "deploy.errorLabel": "Falló el deploy",
+    "deploy.alreadyRolling": "Esta release ya se está desplegando en **{scope}** — muestro ese deployment.",
+    "deploy.rejected": 'Deploy rechazado: {message}\nEsto suele ser la elección de asset, no los ids — el build probablemente tiene varios assets. Reintentá con `application_deployment_create asset:"<nombre>"` (los ves con `application_get`).',
+    "traffic.sayWhat": 'Decime qué hacer: `percent:<0-100>`, `action:"finalize"` o `action:"rollback"`.',
+    "traffic.noActive": "No hay rollout activo en **{app}** — `application_deployment_create` arranca uno.",
+    "traffic.several": "Hay varios rollouts activos — pasá deployment_id:",
+    "traffic.snapped": "({requested}% ajustado a {snapped}%)",
+    "traffic.errorLabel": "Falló la acción de tráfico",
+    "createRelease.noBuilds": "No hay builds exitosos en **{app}** — pusheá un commit para que CI genere uno.",
+    "createRelease.done": "Release **{semver}** creada{from}.",
+    "createRelease.exists": "La release **{semver}** ya existe para el build #{build} — la reuso.",
+    "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.applyHint": "los valores aplican en el próximo `application_deployment_create`.",
+    "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.whichNamespace": "¿Qué namespace?",
+    "createApp.whichNamespaceFor": "¿Qué namespace debería ser dueño de **{name}**?",
+    "createApp.namespaceHint": '`application_create namespace:"<nombre>"`',
+    "createApp.noNamespaces": "Esta organización no tiene namespaces — creá uno en el dashboard primero.",
+    "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.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",
+    // — playbook_get tool —
+    "playbook.errorLabel": "No pude cargar el playbook",
+    "createScope.whichType": "¿Qué tipo de scope para **{name}**?",
+    "createScope.typeHint": '`application_scope_create name:"{name}" type:"<tipo>"`',
+    "createScope.noTypes": 'No hay tipos de scope disponibles — pasá type explícito (p. ej. type:"web_pool").',
+    "createScope.provisioning": "⏳ El scope **{name}** (#{id}, {type}{dimensions}) se está aprovisionando — se está creando infraestructura.",
+    "createScope.exists": "El scope **{name}** (#{id}) ya existe ({status}) — no hay nada que crear.",
+    "createScope.provisioningHint": '`application_get` lo muestra; cuando esté activo, `application_deployment_create scope:"{name}"`.',
+    "createScope.errorLabel": "No pude crear el scope",
+    "error.credentialRejected": "nullplatform rechazó la credencial ({status}) — revisá tu NP_API_KEY",
+    "error.permission": "tu usuario de nullplatform no tiene permisos para esta acción (403)",
+    "error.bearerNoOrg": "el bearer no es un token emitido por nullplatform (sin claim de organización)",
+    "http.authRequired": "autenticación requerida",
+    "http.authHint": "mandá tu propia credencial de nullplatform: `Authorization: Bearer <NP_API_KEY>` (o X-NP-API-Key)",
+    "http.originDenied": "origin no permitido",
+    "http.bodyTooLarge": "el cuerpo del request es demasiado grande",
+    "http.invalidJson": "cuerpo JSON inválido",
+    "http.verifyUnavailable": "no se pudo verificar la credencial con nullplatform",
+    "http.rateLimited": "demasiadas solicitudes — bajá el ritmo",
+    "prompt.ship": `Publicá el último código de {app}{scope}.
+1. Corré status primero y decime qué se va a publicar (build/release).
+2. Hacé deploy.
+3. Subí el tráfico por pasos — 25%, después 50%, después 100% — revisando status entre pasos; frená y avisame si algo se ve mal.
+4. Cuando el 100% esté sano, finalizá y confirmá con un status final.`,
+    "prompt.ship.toScope": ' al scope "{scope}"',
+    "prompt.thisRepoApp": "la aplicación vinculada a este repo",
+    "prompt.setup": `Conectá este repositorio a nullplatform:
+1. Corré application_get — si el repo ya está vinculado a una aplicación, mostrame dónde estoy parado.
+2. Si no está vinculado, buscá con application_list una app que coincida con el nombre del repo antes de crear nada.
+3. Si no existe ninguna, application_create para vincularlo; después mostrá application_get y decime qué sigue (primer build vía CI, después deploy).`,
+    "prompt.health": `Dame un chequeo de salud de {app}:
+1. status — ¿qué está en vivo y dónde? ¿algo a mitad de rollout?
+2. metrics (ventana de 3h) — marcá cualquier cosa rara en throughput, tiempo de respuesta, tasa de errores, CPU o memoria.
+3. logs — escaneá las líneas recientes buscando errores o warnings.
+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"];
+let defaultLocale = "en";
+const localeScope = new AsyncLocalStorage();
+/** Process-wide default (stdio: from NP_LANG/LANG at startup). */
+export function setDefaultLocale(locale) {
+    defaultLocale = locale;
+}
+/** Run `work` with a request-scoped locale (HTTP: from Accept-Language). */
+export function withLocale(locale, work) {
+    return localeScope.run(locale, work);
+}
+export function currentLocale() {
+    return localeScope.getStore() ?? defaultLocale;
+}
+/** English/native language names the model might pass instead of an ISO code. */
+const LANGUAGE_NAMES = {
+    english: "en",
+    inglés: "en",
+    ingles: "en",
+    spanish: "es",
+    español: "es",
+    espanol: "es",
+    castellano: "es",
+};
+/** "es-AR, en;q=0.9" / "es_AR.UTF-8" / "es" / "Spanish" -> a supported locale, or undefined. */
+export function matchLocale(input) {
+    for (const candidate of (input ?? "").split(",")) {
+        const token = candidate.split(";")[0]?.trim().toLowerCase() ?? "";
+        if (!token)
+            continue;
+        const byName = LANGUAGE_NAMES[token];
+        if (byName)
+            return byName;
+        const code = token.slice(0, 2);
+        const supported = SUPPORTED.find((locale) => locale === code);
+        if (supported)
+            return supported;
+    }
+    return undefined;
+}
+/** Like matchLocale, defaulting to en — for transport/env fallbacks. */
+export function resolveLocale(input) {
+    return matchLocale(input) ?? "en";
+}
+/** Translate a message, interpolating `{name}` placeholders. */
+export function translate(key, params) {
+    const template = catalogs[currentLocale()][key];
+    return template.replace(/\{(\w+)\}/g, (placeholder, name) => params?.[name] !== undefined ? String(params[name]) : placeholder);
+}
+/** One/many message pairs — the closest thing to plural rules this catalog needs. */
+export function plural(count, oneKey, manyKey, params) {
+    return translate(count === 1 ? oneKey : manyKey, { count, ...params });
+}