@nullplatform/mcp 0.1.8 → 0.1.10

package/dist/i18n.js

@@ -13,19 +13,19 @@ const english = {
     "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.repoUnlinked": 'This repo ({url}) isn\'t linked to any nullplatform application. Pass app:"<name>" or link it as a new application.',
     "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.noneHint": "create a scope (e.g. a “dev” scope) first, then deploy.",
     "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.createHint": "create the **{name}** scope first.",
+    "scope.deployHint": "name the scope or dimension to deploy onto (e.g. environment=production).",
     "scope.perScope": "{noun} are per scope — which one?",
-    "scope.readHint": '`{tool} scope:"{name}"`',
+    "scope.readHint": "read it for the **{name}** scope.",
     // — table headers —
     "header.app": "App",
     "header.id": "Id",
@@ -100,25 +100,25 @@ const english = {
     "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.rolloutTraffic": "deployment #{id} on **{scope}** is at {traffic}% traffic — move traffic up to advance, finalize once it's at 100%, or roll back to back out.",
+    "hint.rolloutStatus": "deployment #{id} on **{scope}** is {status} — keep watching it roll out.",
+    "hint.noScopes": "no scopes yet — create one (e.g. a “dev” scope) to get a place to deploy.",
+    "hint.buildNewer": "build #{id} ({branch} @{commit}) is newer than release {semver} — deploy it to ship the new code (the release is cut for you).",
+    "hint.buildUnreleased": "build #{id} has no release yet — deploy it to ship (the release is cut for you).",
+    "hint.releaseNotLive": "release {semver} isn't live yet — deploy it to ship.",
+    "hint.noBuilds": "no builds yet — push a commit so CI produces one, then deploy.",
     "hint.upToDate": "everything is up to date ✅",
-    "hint.watch": "`application_get deployment:{id}` to watch.",
+    "hint.watch": "keep watching the rollout to see it land.",
     // — 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.full": "all traffic on the new version — finalize to retire the old one.",
+    "rollout.moving": "traffic moving {from}% → {to}% — keep watching it land.",
+    "rollout.at": "traffic at {traffic}% — move it up to advance (marks: 1, 5, 10, 25, 50, 75, 90, 95, 99, 100%), or roll back to back out.",
+    "rollout.instances": "instances are coming up — keep watching.",
+    "rollout.switching": "traffic is switching — keep watching.",
     "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.failed": "deployment failed — check the logs for output, and roll back if traffic moved.",
     "rollout.rolledBack": "rolled back — previous version is serving all traffic.",
     // — application_get tool —
     "status.errorLabel": "Couldn't load status",
@@ -126,21 +126,21 @@ const english = {
     "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.createHint": "link 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.statusHint": "ask for one by name to see its full picture.",
     "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.unavailable": "Parameter listing isn't available here, but setting parameters 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.noneHint": "add an env var or file parameter to get started.",
     "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.applyHint": "changed values apply on the next deploy.",
     "params.effectiveFor": "**{app}** · effective parameters for **{scope}**",
     "params.ctxApplication": "Application",
     "params.ctxScope": "{scope} (scope)",
@@ -148,7 +148,7 @@ const english = {
     // — 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.noScopesHint": "create a scope and deploy — logs appear once something runs.",
     "logs.empty": "No log lines returned for **{app}**{scope}.",
     "logs.openInDashboard": "open logs in dashboard",
     "logs.lastLines.one": "**{app}**{scope} — last line",
@@ -158,7 +158,7 @@ const english = {
     // — 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.noScopesHint": "create a scope and deploy to start collecting metrics.",
     "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}",
@@ -171,9 +171,9 @@ const english = {
     "builds.released": "Released",
     "builds.none": "**{app}** has no builds yet.",
     "builds.noneForCommit": "No build in **{app}** for commit `{commit}` — it may not have built yet, or the commit isn't on a built branch.",
-    "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.noneHint": "push a commit so CI produces one, then deploy.",
+    "builds.deployHint": "deploy build #{build} to ship it (the release is cut for you).",
+    "builds.waiting": "build #{build} is still running — check again in a moment.",
     "builds.upToDate": "the latest successful build is already released.",
     "builds.assetsTitle": "Assets of build #{build}",
     "builds.noAssets": "Build #{build} has no assets.",
@@ -183,23 +183,23 @@ const english = {
     "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.noneHint": "cut one from a successful build, or just deploy (it cuts the release for you).",
+    "releaseList.deployHint": "deploy an active release by version (e.g. x.y.z).",
     "releaseList.errorLabel": "Couldn't list releases",
     "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.hint": "ask for the app's status to see the live picture, or drive a rollout's traffic.",
     "deploymentList.errorLabel": "Couldn't list deployments",
     // — organization_get tool —
     "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.truncated": "_(showing the first {count} — narrow with a query to see more)_",
     "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.hintActive": "open **{app}** to watch a rollout, or drive its traffic.",
+    "overview.hintTrouble": "check the logs of **{app}** to investigate, and roll back if needed.",
     "overview.hintCalm": "everything is steady — nothing rolling out, nothing failed.",
     "overview.errorLabel": "Couldn't build the overview",
     // — application_approval_list tool —
@@ -210,10 +210,10 @@ const english = {
     "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.invalidId": "That doesn't look like a valid approval id — copy it from the approvals 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.actHint": "approve {id} to let it proceed (uses your permissions).",
     "approvals.errorLabel": "Couldn't load approvals",
     // — application_service_list tool —
     "services.attached.one": "**{app}** · 1 dependency service",
@@ -230,19 +230,19 @@ const english = {
     "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.pickHint": "name a dependency type 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.",
+    "createService.provisioningHint": "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.noServicesHint": "provision a dependency service 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.pickHint": "name a service 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.",
@@ -252,15 +252,15 @@ const english = {
     // — 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.noServicesHint": "provision a dependency service first.",
     "runAction.noLinks": "**{app}** has no links to run an action on.",
-    "runAction.noLinksHint": "`application_link_create` to link a service first.",
+    "runAction.noLinksHint": "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.pickServiceHint": "name a service 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.pickLinkHint": "name a link 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:",
@@ -277,12 +277,12 @@ const english = {
     "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.pickServiceHint": "name a service 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.pickLinkHint": "name a link 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.hasLinksHint": "delete the links first, 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.",
@@ -292,7 +292,7 @@ const english = {
     "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.readOnlyHint": "delete the link that exports it instead.",
     "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}**.",
@@ -300,22 +300,22 @@ const english = {
     "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}"`',
+    "deploy.createScopeHint": "create a scope first (e.g. a “dev” scope of 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.nothingHint": "push a commit so CI produces a build, then deploy again.",
     "deploy.multiAsset": "Build #{build} has several assets — which one ships to **{scope}** ({type})?",
-    "deploy.assetHint": '`application_deployment_create asset:"{name}"`',
+    "deploy.assetHint": "deploy again, naming the asset to ship (e.g. {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`).',
+    "deploy.rejected": "Deploy rejected: {message}\nThis usually means the asset choice, not the ids — the build likely has several assets. Retry naming the asset to ship (the status view lists them).",
     // — 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.sayWhat": "Tell me what to do: set a traffic percentage (0–100), finalize, or roll back.",
+    "traffic.noActive": "No active rollout on **{app}** — deploy to start one.",
     "traffic.several": "Several rollouts are active — pass deployment_id:",
     "traffic.snapped": "({requested}% snapped to {snapped}%)",
     "traffic.errorLabel": "Traffic action failed",
@@ -324,7 +324,7 @@ const english = {
     "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.deployHint": "deploy release #{id} to ship it.",
     "createRelease.errorLabel": "Couldn't create release",
     // — application_parameter_create tool —
     "setParams.created.one": "Set 1 new parameter on **{app}**: {names}.",
@@ -332,9 +332,9 @@ const english = {
     "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.applyHint": "values apply on the next deploy.",
     "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.partial": "Parameter update failed partway: {message}\nAlready-created parameters remain — list them 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}.",
@@ -343,24 +343,24 @@ const english = {
     "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>"`',
+    "createApp.namespaceHint": "name the namespace to create it in.",
     "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.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.createdHint": "push a commit to trigger the first build, then deploy.",
+    "createApp.createdHintNew": "the repo was scaffolded for you — clone {repo} into a folder, add your code there, and push so CI builds it, then deploy.",
     "createApp.pending": "⏳ **{name}** created (#{id}), provisioning is still running (status: {status}).",
-    "createApp.pendingHint": '`application_get app:"#{id}"` to check on it.',
+    "createApp.pendingHint": "check on application #{id} to see its progress.",
     "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.typeHint": "name a scope type for **{name}** to create it.",
     "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.provisioningHint": "its status shows it; once active, deploy to the **{name}** scope.",
     "createScope.errorLabel": "Couldn't create scope",
     // — auth & transport —
     "error.credentialRejected": "nullplatform rejected the credential ({status}) — check your NP_API_KEY",
@@ -382,32 +382,32 @@ const english = {
     "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).`,
+1. Check this app's status — if the repo is already linked to an application, just show me where I stand.
+2. If it isn't linked, search for an app matching this repo's name before creating anything.
+3. If none exists, create the application to link it, then show its status 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.`,
+    "prompt.rollback": `Something is wrong — roll back {app} right now: find its active rollout, roll it back, then confirm from its status 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.repoUnlinked": 'Este repo ({url}) no está vinculado a ninguna aplicación de nullplatform. Pasá app:"<nombre>" o vinculalo como una aplicación nueva.',
     "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.noneHint": "creá un scope (por ejemplo un scope “dev”) primero, después deployá.",
     "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.createHint": "creá el scope **{name}** primero.",
+    "scope.deployHint": "nombrá el scope o dimensión donde deployar (p. ej. environment=production).",
     "scope.perScope": "{noun} son por scope — ¿cuál?",
-    "scope.readHint": '`{tool} scope:"{name}"`',
+    "scope.readHint": "leelo para el scope **{name}**.",
     "header.app": "App",
     "header.id": "Id",
     "header.namespace": "Namespace",
@@ -477,50 +477,50 @@ const spanish = {
     "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.rolloutTraffic": "el deployment #{id} en **{scope}** está al {traffic}% de tráfico — subí el tráfico para avanzar, finalizá cuando llegue a 100%, o volvé atrás con un rollback.",
+    "hint.rolloutStatus": "el deployment #{id} en **{scope}** está {status} — seguí el rollout para ver cómo avanza.",
+    "hint.noScopes": "sin scopes todavía — creá uno (por ejemplo un scope “dev”) para tener dónde deployar.",
+    "hint.buildNewer": "el build #{id} ({branch} @{commit}) es más nuevo que la release {semver} — deployalo para publicar el código nuevo (la release se crea sola).",
+    "hint.buildUnreleased": "el build #{id} todavía no tiene release — deployalo para publicarlo (la release se crea sola).",
+    "hint.releaseNotLive": "la release {semver} todavía no está en vivo — deployala para publicarla.",
+    "hint.noBuilds": "sin builds todavía — pusheá un commit para que CI genere uno, después deployá.",
     "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.",
+    "hint.watch": "seguí el rollout para verlo aterrizar.",
+    "rollout.full": "todo el tráfico en la versión nueva — finalizá para retirar la vieja.",
+    "rollout.moving": "el tráfico va de {from}% → {to}% — seguí cómo aterriza.",
+    "rollout.at": "tráfico al {traffic}% — subilo para avanzar (marcas: 1, 5, 10, 25, 50, 75, 90, 95, 99, 100%), o volvé atrás con un rollback.",
+    "rollout.instances": "las instancias están levantando — seguí el rollout.",
+    "rollout.switching": "el tráfico se está moviendo — seguí el rollout.",
     "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.failed": "el deployment falló — revisá los logs para ver la salida, y volvé atrás con un 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.createHint": "vinculá 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.statusHint": "pedí una por nombre para ver su panorama completo.",
     "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.unavailable": "El listado de parámetros no está disponible acá, pero setear parámetros 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.noneHint": "agregá una variable de entorno o un archivo para empezar.",
     "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.applyHint": "los valores cambiados aplican en el próximo deploy.",
     "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.noScopesHint": "creá un scope y deployá — 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.one": "**{app}**{scope} — última línea",
@@ -529,7 +529,7 @@ const spanish = {
     "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.noScopesHint": "creá un scope y deployá para empezar a juntar métricas.",
     "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}",
@@ -542,9 +542,9 @@ const spanish = {
     "builds.released": "Released",
     "builds.none": "**{app}** todavía no tiene builds.",
     "builds.noneForCommit": "Ningún build en **{app}** para el commit `{commit}` — puede que todavía no haya buildeado, o que el commit no esté en una branch que buildea.",
-    "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.noneHint": "pusheá un commit para que CI genere uno, después deployá.",
+    "builds.deployHint": "deployá el build #{build} para publicarlo (la release se crea sola).",
+    "builds.waiting": "el build #{build} sigue corriendo — chequeá de nuevo en un momento.",
     "builds.upToDate": "el último build exitoso ya está publicado.",
     "builds.assetsTitle": "Assets del build #{build}",
     "builds.noAssets": "El build #{build} no tiene assets.",
@@ -554,23 +554,23 @@ const spanish = {
     "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.noneHint": "cortá una desde un build exitoso, o directamente deployá (corta la release por vos).",
+    "releaseList.deployHint": "deployá una release activa por versión (ej. x.y.z).",
     "releaseList.errorLabel": "No pude listar los releases",
     "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.hint": "pedí el estado de la app para la foto en vivo, o manejá el tráfico de un rollout.",
     "deploymentList.errorLabel": "No pude listar los deployments",
     // — organization_get tool —
     "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.truncated": "_(muestro las primeras {count} — acotá con una búsqueda para ver más)_",
     "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.hintActive": "abrí **{app}** para seguir un rollout, o manejá su tráfico.",
+    "overview.hintTrouble": "revisá los logs de **{app}** para investigar, y volvé atrás con un rollback si hace falta.",
     "overview.hintCalm": "todo tranquilo — nada desplegándose, nada falló.",
     "overview.errorLabel": "No pude armar el panorama",
     // — application_approval_list tool —
@@ -581,10 +581,10 @@ const spanish = {
     "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.invalidId": "Eso no parece un approval id válido — copialo de la lista de aprobaciones.",
     "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.actHint": "aprobá {id} para dejarla continuar (usa tus permisos).",
     "approvals.errorLabel": "No pude cargar las aprobaciones",
     // — application_service_list tool —
     "services.attached.one": "**{app}** · 1 servicio de dependencia",
@@ -601,19 +601,19 @@ const spanish = {
     "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.pickHint": "nombrá un tipo de dependencia 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.",
+    "createService.provisioningHint": "linkeá **{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.noServicesHint": "provisioná un servicio de 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.pickHint": "nombrá un servicio 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.",
@@ -623,15 +623,15 @@ const spanish = {
     // — 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.noServicesHint": "provisioná un servicio de dependencia primero.",
     "runAction.noLinks": "**{app}** no tiene links para correr una acción.",
-    "runAction.noLinksHint": "`application_link_create` para linkear un servicio primero.",
+    "runAction.noLinksHint": "linkeá 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.pickServiceHint": "nombrá un servicio 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.pickLinkHint": "nombrá un link 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:",
@@ -648,12 +648,12 @@ const spanish = {
     "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.pickServiceHint": "nombrá un servicio 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.pickLinkHint": "nombrá un link 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.hasLinksHint": "borrá los links primero, 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.",
@@ -663,28 +663,28 @@ const spanish = {
     "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.readOnlyHint": "borrá el link que lo exporta.",
     "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.createScopeHint": "creá un scope primero (por ejemplo un scope “dev” de tipo {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.nothingHint": "pusheá un commit para que CI genere un build y después deployá de nuevo.",
     "deploy.multiAsset": "El build #{build} tiene varios assets — ¿cuál va a **{scope}** ({type})?",
-    "deploy.assetHint": '`application_deployment_create asset:"{name}"`',
+    "deploy.assetHint": "deployá de nuevo, nombrando el asset a publicar (ej. {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.",
+    "deploy.rejected": "Deploy rechazado: {message}\nEsto suele ser la elección de asset, no los ids — el build probablemente tiene varios assets. Reintentá nombrando el asset a publicar (los ves en el estado de la app).",
+    "traffic.sayWhat": "Decime qué hacer: poné un porcentaje de tráfico (0–100), finalizá, o volvé atrás con un rollback.",
+    "traffic.noActive": "No hay rollout activo en **{app}** — deployá para arrancar 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",
@@ -692,16 +692,16 @@ const spanish = {
     "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.deployHint": "deployá la release #{id} para publicarla.",
     "createRelease.errorLabel": "No pude crear la release",
     "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.applyHint": "los valores aplican en el próximo deploy.",
     "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.partial": "La actualización de parámetros falló a mitad de camino: {message}\nLos parámetros ya creados quedan — listalos 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.",
@@ -709,23 +709,23 @@ const spanish = {
     "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>"`',
+    "createApp.namespaceHint": "nombrá el namespace donde crearla.",
     "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.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.createdHint": "pusheá un commit para disparar el primer build y después deployá.",
+    "createApp.createdHintNew": "el repo fue scaffoldeado — cloná {repo} en una carpeta, agregá tu código ahí y pusheá para que CI buildee, después deployá.",
     "createApp.pending": "⏳ **{name}** creada (#{id}), el aprovisionamiento sigue corriendo (estado: {status}).",
-    "createApp.pendingHint": '`application_get app:"#{id}"` para revisarla.',
+    "createApp.pendingHint": "revisá la aplicación #{id} para ver cómo va.",
     "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.typeHint": "nombrá un tipo de scope para **{name}** para crearlo.",
     "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.provisioningHint": "el estado de la app lo muestra; cuando esté activo, deployá al 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)",
@@ -745,34 +745,34 @@ const spanish = {
     "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).`,
+1. Mostrame el estado de esta app — si el repo ya está vinculado a una aplicación, mostrame dónde estoy parado.
+2. Si no está vinculado, buscá una app que coincida con el nombre del repo antes de crear nada.
+3. Si no existe ninguna, creá la aplicación para vincularlo; después mostrá su estado 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ó.`,
+    "prompt.rollback": `Algo está mal — revertí {app} ya mismo: encontrá su rollout activo, revertilo y confirmá desde su estado que la versión anterior está sirviendo tráfico; resumí qué se revirtió.`,
 };
 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.repoUnlinked": 'Este repositório ({url}) não está vinculado a nenhuma aplicação nullplatform. Passe app:"<nome>" ou vincule-o como uma nova aplicação.',
     "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.noneHint": "crie um scope (por exemplo um scope “dev”) primeiro, depois faça o deploy.",
     "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.createHint": "crie o scope **{name}** primeiro.",
+    "scope.deployHint": "informe o scope ou a dimensão onde fazer o deploy (ex. environment=production).",
     "scope.perScope": "{noun} são por scope — qual?",
-    "scope.readHint": '`{tool} scope:"{name}"`',
+    "scope.readHint": "leia para o scope **{name}**.",
     // — table headers —
     "header.app": "App",
     "header.id": "Id",
@@ -847,25 +847,25 @@ const portuguese = {
     "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.rolloutTraffic": "deployment #{id} em **{scope}** está com {traffic}% de tráfego — aumente o tráfego para avançar, finalize quando chegar a 100%, ou reverta para voltar atrás.",
+    "hint.rolloutStatus": "deployment #{id} em **{scope}** está {status} — acompanhe o rollout para ver como avança.",
+    "hint.noScopes": "ainda sem scopes — crie um (por exemplo um scope “dev”) para ter onde fazer deploy.",
+    "hint.buildNewer": "build #{id} ({branch} @{commit}) é mais novo que a release {semver} — faça o deploy para publicar o código novo (a release é criada para você).",
+    "hint.buildUnreleased": "build #{id} ainda não tem release — faça o deploy para publicá-lo (a release é criada para você).",
+    "hint.releaseNotLive": "a release {semver} ainda não está no ar — faça o deploy para publicá-la.",
+    "hint.noBuilds": "ainda sem builds — faça push de um commit para o CI gerar um, depois faça o deploy.",
     "hint.upToDate": "está tudo atualizado ✅",
-    "hint.watch": "`application_get deployment:{id}` para acompanhar.",
+    "hint.watch": "acompanhe o rollout para vê-lo concluir.",
     // — 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.full": "todo o tráfego na nova versão — finalize para aposentar a antiga.",
+    "rollout.moving": "tráfego indo de {from}% → {to}% — acompanhe a conclusão.",
+    "rollout.at": "tráfego em {traffic}% — aumente para avançar (marcas: 1, 5, 10, 25, 50, 75, 90, 95, 99, 100%), ou reverta para voltar atrás.",
+    "rollout.instances": "as instâncias estão subindo — acompanhe o rollout.",
+    "rollout.switching": "o tráfego está sendo trocado — acompanhe o rollout.",
     "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.failed": "o deployment falhou — verifique os logs para ver a saída, e reverta 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",
@@ -873,21 +873,21 @@ const portuguese = {
     "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.createHint": "vincule 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.statusHint": "peça uma pelo nome para ver o panorama completo.",
     "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.unavailable": "A listagem de parâmetros não está disponível aqui, mas definir parâmetros 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.noneHint": "adicione uma variável de ambiente ou arquivo para começar.",
     "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.applyHint": "valores alterados aplicam no próximo deploy.",
     "params.effectiveFor": "**{app}** · parâmetros efetivos para **{scope}**",
     "params.ctxApplication": "Aplicação",
     "params.ctxScope": "{scope} (scope)",
@@ -895,7 +895,7 @@ const portuguese = {
     // — 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.noScopesHint": "crie um scope e faça o deploy — 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",
@@ -905,7 +905,7 @@ const portuguese = {
     // — 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.noScopesHint": "crie um scope e faça o deploy para começar a coletar métricas.",
     "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}",
@@ -918,9 +918,9 @@ const portuguese = {
     "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.noneHint": "faça push de um commit para o CI gerar um, depois faça o deploy.",
+    "builds.deployHint": "faça o deploy do build #{build} para publicá-lo (a release é criada para você).",
+    "builds.waiting": "o build #{build} ainda está rodando — verifique de novo em instantes.",
     "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.",
@@ -930,23 +930,23 @@ const portuguese = {
     "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.noneHint": "corte uma a partir de um build bem-sucedido, ou simplesmente faça o deploy (ele corta a release para você).",
+    "releaseList.deployHint": "faça o deploy de uma release ativa por versão (ex. 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.hint": "peça o status da app para o panorama ao vivo, ou conduza o tráfego de 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.truncated": "_(mostrando as primeiras {count} — refine com uma query para ver mais)_",
     "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.hintActive": "abra **{app}** para acompanhar um rollout, ou conduza o tráfego dele.",
+    "overview.hintTrouble": "verifique os logs de **{app}** para investigar, e reverta 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 —
@@ -957,10 +957,10 @@ const portuguese = {
     "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.invalidId": "Isso não parece um approval id válido — copie-o da lista de aprovações.",
     "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.actHint": "aprove {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",
@@ -977,19 +977,19 @@ const portuguese = {
     "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.pickHint": "informe um tipo de dependência 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.",
+    "createService.provisioningHint": "linke **{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.noServicesHint": "provisione um serviço de 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.pickHint": "informe um serviço 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.",
@@ -999,15 +999,15 @@ const portuguese = {
     // — 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.noServicesHint": "provisione um serviço de 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.noLinksHint": "linke 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.pickServiceHint": "informe um serviço 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.pickLinkHint": "informe um link 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:",
@@ -1024,12 +1024,12 @@ const portuguese = {
     "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.pickServiceHint": "informe um serviço 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.pickLinkHint": "informe um link 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.hasLinksHint": "delete os links primeiro, 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.",
@@ -1039,7 +1039,7 @@ const portuguese = {
     "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.readOnlyHint": "delete o link que o exporta.",
     "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}**.",
@@ -1047,22 +1047,22 @@ const portuguese = {
     "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.createScopeHint": "crie um scope primeiro (por exemplo um scope “dev” do tipo {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.nothingHint": "faça push de um commit para o CI gerar um build, depois faça o deploy de novo.",
     "deploy.multiAsset": "O build #{build} tem vários assets — qual vai para **{scope}** ({type})?",
-    "deploy.assetHint": '`application_deployment_create asset:"{name}"`',
+    "deploy.assetHint": "faça o deploy de novo, informando o asset a publicar (ex. {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`).',
+    "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 informando o asset a publicar (veja-os no status da app).",
     // — 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.sayWhat": "Diga o que fazer: defina uma porcentagem de tráfego (0–100), finalize, ou reverta.",
+    "traffic.noActive": "Nenhum rollout ativo em **{app}** — faça o deploy para iniciar 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",
@@ -1071,7 +1071,7 @@ const portuguese = {
     "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.deployHint": "faça o deploy da release #{id} para publicá-la.",
     "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}.",
@@ -1079,9 +1079,9 @@ const portuguese = {
     "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.applyHint": "os valores aplicam no próximo deploy.",
     "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.partial": "A atualização de parâmetros falhou no meio: {message}\nOs parâmetros já criados permanecem — liste-os 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}.",
@@ -1090,24 +1090,24 @@ const portuguese = {
     "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.namespaceHint": "informe o namespace onde criá-la.",
     "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.createdHint": "faça push de um commit para disparar o primeiro build, depois faça o deploy.",
+    "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 faça o deploy.",
     "createApp.pending": "⏳ **{name}** criada (#{id}), o provisionamento ainda está rodando (status: {status}).",
-    "createApp.pendingHint": '`application_get app:"#{id}"` para checá-la.',
+    "createApp.pendingHint": "verifique a aplicação #{id} para ver o progresso.",
     "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.typeHint": "informe um tipo de scope para **{name}** para criá-lo.",
     "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.provisioningHint": "o status da app o mostra; quando ativo, faça o deploy no 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",
@@ -1129,15 +1129,15 @@ const portuguese = {
     "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).`,
+1. Mostre o status desta app — se o repositório já estiver vinculado a uma aplicação, apenas me mostre onde estou.
+2. Se não estiver vinculado, procure uma app com o nome deste repositório antes de criar qualquer coisa.
+3. Se nenhuma existir, crie a aplicação para vinculá-lo, depois mostre o status dela 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.`,
+    "prompt.rollback": `Algo está errado — reverta {app} agora mesmo: encontre seu rollout ativo, reverta-o, depois confirme pelo status dele 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"];

package/dist/render.js

@@ -1,9 +1,18 @@
 import { translate } from "./i18n.js";
 import { ago, glyph, linkLine, next, shortCommit, statusLabel, table } from "./md.js";
 import { isDeploymentTerminal } from "./np/journey.js";
+/** "owner/repo" from a git URL (https or ssh), for a readable link label. */
+const repoSlug = (url) => url
+    .replace(/\.git$/, "")
+    .split(/[/:]/)
+    .filter(Boolean)
+    .slice(-2)
+    .join("/");
 export function renderAppHeader(app) {
     const where = [app.namespace, app.account].filter(Boolean).join(" / ");
-    const repo = app.repository_url ? `\nrepo ${app.repository_url}` : "";
+    // Render the repo as a real link (label = owner/repo) instead of a bare URL, so a text host
+    // surfaces it as something clickable.
+    const repo = app.repository_url ? linkLine(repoSlug(app.repository_url), app.repository_url) : "";
     return `**${app.name}** · #${app.id}${where ? ` · ${where}` : ""}${repo}`;
 }
 function trafficBar(percent) {
@@ -22,7 +31,7 @@ export function renderScopeRows(views) {
         return translate("render.noScopes");
     const domains = views
         .filter((view) => view.scope.domain && view.current && view.current.status === "finalized")
-        .map((view) => `- ${view.scope.name}: https://${view.scope.domain}`);
+        .map((view) => `- ${view.scope.name}: [${view.scope.domain}](https://${view.scope.domain})`);
     const scopeTable = table([
         translate("header.scope"),
         translate("header.status"),
@@ -101,8 +110,11 @@ export function renderStatus(args) {
             : ""}`;
     })
         .join(" · ");
+    const commitRef = latestBuild?.commit_url
+        ? `[@${shortCommit(latestBuild.commit)}](${latestBuild.commit_url})`
+        : `@${shortCommit(latestBuild?.commit)}`;
     const latestBuildLine = latestBuild
-        ? `${glyph(latestBuild.status)} #${latestBuild.id} ${latestBuild.branch ?? ""} @${shortCommit(latestBuild.commit)} (${ago(latestBuild.created_at)})`
+        ? `${glyph(latestBuild.status)} #${latestBuild.id} ${latestBuild.branch ?? ""} ${commitRef} (${ago(latestBuild.created_at)})`
         : translate("render.noBuilds");
     const lines = [
         renderAppHeader(app),

package/package.json

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