@biznetgio/neo-app 0.4.41 → 0.4.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biznetgio/neo-app",
-  "version": "0.4.41",
+  "version": "0.4.43",
   "description": "NEO App CLI — one-command agent onboarding, MCP server, and project ops for coding agents (Codex, Claude Code).",
   "type": "module",
   "bin": {

package/src/commands/deploy.js

@@ -8,7 +8,7 @@ import { getCredential } from '../creds.js';
 import { NeoApi } from '../api.js';
 import { readLink } from '../link.js';
 import { deploySource } from '../deploySource.js';
-import { log, ok, fail, warn, step, c } from '../util.js';
+import { log, ok, fail, warn, step, c, confirm } from '../util.js';
 
 function isGitUrl(s) {
   if (!s) return false;
@@ -29,6 +29,13 @@ function isDir(s) {
   }
 }
 
+function showCost(r) {
+  if (r?.estimatedCost) {
+    const e = r.estimatedCost;
+    log(c.bold(`Estimated cost: ~${e.monthly} ${e.currency}/mo (${e.hourly}/h)`) + (e.assumptions ? c.dim(` — ${e.assumptions}`) : ''));
+  }
+}
+
 export async function deploy(source, opts = {}) {
   // `--source <path|.zip|git-url>` is an explicit alias for the positional source, as
   // documented in the deploy examples (JNG #75/#79); the positional still works.
@@ -74,7 +81,7 @@ export async function deploy(source, opts = {}) {
   const dryRun = !!opts['dry-run'];
   if (dryRun) log(c.dim('dry-run — no changes will be made'));
 
-  const r = await deploySource(api, {
+  const base = {
     projectId,
     src,
     name: opts.name,
@@ -82,12 +89,33 @@ export async function deploy(source, opts = {}) {
     port: opts.port,
     build: opts.build,
     environment,
-    dryRun,
     timeout: Number(opts.timeout) || 300,
     log: step,
-  });
+  };
+
+  // Cost gate: a real deploy is billable, so it needs explicit approval. `--yes` approves
+  // up front (headless/CI); otherwise preview the cost first, then confirm (interactive)
+  // or require `--yes` (non-interactive). A spec-bound confirmToken links the approval to
+  // the exact cost shown, so nothing deploys if the spec drifts.
+  let confirmToken;
+  if (!dryRun && !opts.yes) {
+    const prev = await deploySource(api, { ...base, dryRun: true });
+    showCost(prev);
+    if (!process.stdin.isTTY) {
+      fail('billable deploy — re-run with --yes to approve (non-interactive)');
+      process.exit(1);
+    }
+    if (!(await confirm('Proceed with this billable deploy?'))) {
+      ok('cancelled — nothing deployed');
+      return prev;
+    }
+    confirmToken = prev.confirmToken;
+  }
+
+  const r = await deploySource(api, { ...base, dryRun, confirm: !!opts.yes, confirmToken });
 
   if (r.dryRun) {
+    showCost(r);
     ok(`dry-run complete — ${r.plan.length} step(s) planned, nothing written`);
     return r;
   }

package/src/deploySource.js

@@ -155,7 +155,7 @@ function looksStatic(dir) {
 // With `dryRun`, it performs NO create/update/upload/deploy — only the GETs needed to
 // build a plan — and returns { dryRun:true, plan } (JNG #93).
 // Returns { pending, approvalId } or { appId, url, result }. `log(msg)` is optional.
-export async function deploySource(api, { projectId, src, name, port, build, serviceType, buildCommand, publishDirectory, environment, confirmToken, dryRun = false, timeout = 300, log = () => {} }) {
+export async function deploySource(api, { projectId, src, name, port, build, serviceType, buildCommand, publishDirectory, environment, confirmToken, confirm = false, dryRun = false, timeout = 300, log = () => {} }) {
   const defaultName =
     src.mode === 'image' ? src.image.split('/').pop().split(':')[0]
     : src.mode === 'git' ? basename(src.repo, '.git')
@@ -220,10 +220,16 @@ export async function deploySource(api, { projectId, src, name, port, build, ser
     }
   }
 
+  // Cost gate (0.4.40 retest A — a bare deploy must not create a billable service with
+  // no cost consent): a real deploy needs explicit approval BEFORE any mutation —
+  // either confirm:true or a matching confirmToken from a prior dry-run. Unapproved →
+  // run read-only (like a dry-run) and return requiresConfirmation.
+  const previewOnly = dryRun || !(confirmToken || confirm === true);
+
   const plan = [];
   if (!app) {
     plan.push(`create ${svcType} service "${svc}" (${buildType}) in ${targetEnv}`);
-    if (!dryRun) {
+    if (!previewOnly) {
       const res = await api.post(`/api/v1/projects/${projectId}/apps`, {
         name: svc,
         environment: targetEnv,
@@ -264,7 +270,7 @@ export async function deploySource(api, { projectId, src, name, port, build, ser
     if (buildType && app.buildType && app.buildType !== buildType) patch.buildType = buildType;
     if (Object.keys(patch).length) {
       plan.push(`update "${svc}": ${Object.keys(patch).join(', ')}`);
-      if (!dryRun) {
+      if (!previewOnly) {
         const upd = await api.put(`/api/v1/apps/${app.id}`, patch);
         // If the source-config update needs approval, STOP — deploying now would ship
         // the OLD config while the change is still pending (JNG #96 re-validation).
@@ -279,28 +285,37 @@ export async function deploySource(api, { projectId, src, name, port, build, ser
   if (src.mode === 'dir' || src.mode === 'zip') plan.push(`upload build context (${src.mode})`);
   plan.push(`deploy "${svc}"`);
 
-  if (dryRun) {
-    for (const p of plan) log(`[dry-run] would ${p}`);
-    // Cost confirmation before a billable deploy (handoff 3.3/3.4). A new service
-    // starts on the default compute tier; estimate from the live price book so the
-    // user sees the cost in the dry-run. Best-effort — never fail the dry-run on it.
+  const token = deployToken({ svc, targetEnv, svcType, port, buildCommand, publishDirectory, src });
+  // Build the cost preview (+ spec-bound confirmToken) once — used for the dry-run AND
+  // for the mandatory pre-deploy gate below.
+  const buildPreview = async () => {
     let estimatedCost;
     try {
       const book = (await api.get('/api/v1/pricing')).data;
       estimatedCost = estimateCost(book, { computeTier: 'micro' });
+    } catch { /* price book unavailable — skip the estimate */ }
+    return { dryRun: true, plan, service: svc, environment: targetEnv, serviceType: svcType, estimatedCost, confirmToken: token };
+  };
+
+  // Preview path (explicit dry-run OR an unapproved real deploy). No mutation ran above,
+  // so this returns the cost + spec-bound confirmToken and deploys NOTHING. An explicit
+  // dry-run returns the plain preview; an unapproved real deploy adds requiresConfirmation
+  // (MANDATORY gate 0.4.40 retest A — a bare deploy previously created a billable service
+  // with no cost consent).
+  if (previewOnly) {
+    for (const p of plan) log(`[dry-run] would ${p}`);
+    const prev = await buildPreview();
+    if (prev.estimatedCost) {
       const build = svcType === 'static_site' ? 'native nginx static hosting (not Railpack)' : 'built server-side';
-      log(`[dry-run] estimated cost (${svcType}, ${build}, default micro compute): ~${estimatedCost.monthly} ${estimatedCost.currency}/mo (${estimatedCost.hourly}/h) — ${estimatedCost.assumptions}. Use neo_estimate for a specific size.`);
-    } catch { /* price book unavailable — skip the estimate, not the dry-run */ }
-    return { dryRun: true, plan, service: svc, environment: targetEnv, serviceType: svcType, estimatedCost, confirmToken: deployToken({ svc, targetEnv, svcType, port, buildCommand, publishDirectory, src }) };
+      log(`[dry-run] estimated cost (${svcType}, ${build}, default micro compute): ~${prev.estimatedCost.monthly} ${prev.estimatedCost.currency}/mo (${prev.estimatedCost.hourly}/h) — ${prev.estimatedCost.assumptions}. Use neo_estimate for a specific size.`);
+    }
+    if (dryRun) return prev;
+    return { ...prev, requiresConfirmation: true, note: 'Billable deploy — show the user the cost, then re-call with this confirmToken (or confirm:true) to deploy. Nothing was deployed.' };
   }
 
-  // Crypto link: if the caller passed the dry-run's confirmToken, the spec about to
-  // deploy must still hash to it — otherwise the cost/spec the user approved changed.
-  if (confirmToken) {
-    const now = deployToken({ svc, targetEnv, svcType, port, buildCommand, publishDirectory, src });
-    if (now !== confirmToken) {
-      throw new Error(`deploy spec changed since the dry-run (confirmToken ${confirmToken} → ${now}) — re-run with dryRun:true, show the new cost, and confirm again`);
-    }
+  // Approved deploy. A supplied confirmToken must still match the resolved spec (cost unchanged).
+  if (confirmToken && token !== confirmToken) {
+    throw new Error(`deploy spec changed since the dry-run (confirmToken ${confirmToken} → ${token}) — re-run with dryRun:true, show the new cost, and confirm again`);
   }
 
   if (src.mode === 'dir' || src.mode === 'zip') {

package/src/index.js

@@ -33,7 +33,7 @@ ${c.bold('Options')}
   --agent <codex|claude-code>   Target one agent (config install-mcp)
   --url <url>              Override the control-plane URL (also NEO_APP_URL)
   --token <kap_...>        API key (also NEO_APP_TOKEN; prompted if omitted)
-  --yes                    Non-interactive (headless/CI)
+  --yes                    Non-interactive (headless/CI); also approves a billable deploy without the cost prompt
   --dry-run               Print intended changes without writing
   -v, --version           Print version
   -h, --help              Show this help`;

package/src/mcp/tools.js

@@ -87,6 +87,53 @@ async function confirmCost(api, args, spec) {
   };
 }
 
+// billableGate routes a billable one-shot create through the SAME server-side generic
+// confirmation subsystem as deletes (handoff: generic confirmation for billable creates),
+// so every create is approved + audited server-side and single-use. It returns either:
+//   { query }               — append to the create POST; the server consumes the confirmation
+//   { requiresConfirmation } — a preview; CREATES NOTHING
+// A confirmationId re-plays an already-approved confirmation; confirm:true is a one-call
+// shortcut that mints + auto-approves one; neither returns the cost + a pending confirmationId.
+async function billableGate(api, { projectId, kind, name, confirmationId, confirm }, spec) {
+  if (confirmationId) return { query: `?confirmationId=${encodeURIComponent(confirmationId)}` };
+
+  // Estimate the cost (best-effort) for display and the confirmation summary.
+  let orgId = null;
+  try { orgId = await api.resolveOrgId(); } catch { orgId = null; }
+  let book = null;
+  try { book = (await api.get(orgId ? `/api/v1/orgs/${orgId}/pricing` : '/api/v1/pricing')).data; }
+  catch { try { book = (await api.get('/api/v1/pricing')).data; } catch { book = null; } }
+  let cost = null;
+  if (book) { try { cost = estimateCost(book, spec); } catch { cost = null; } }
+  const costNote = cost ? `~${cost.monthly} ${cost.currency}/mo (${cost.hourly}/h)` : '';
+
+  // Mint a server-side billable_create confirmation bound to this exact resource.
+  // Retry a transient 5xx/dropped connection: minting has no lasting side effect (an
+  // unused pending confirmation just expires), so this is safe and keeps a flaky gateway
+  // from failing an otherwise-fine create (same spirit as the api-layer idempotent retry).
+  let mint;
+  for (let attempt = 1; ; attempt++) {
+    try { mint = (await api.post('/api/v1/confirmations', { action: 'billable_create', projectId, kind, name, estimatedCost: costNote })).data; break; }
+    catch (e) {
+      if (attempt < 3 && (e?.status >= 500 || e?.status === 0)) { await new Promise((r) => setTimeout(r, 300 * attempt)); continue; }
+      throw e;
+    }
+  }
+  const id = mint.confirmationId;
+  if (confirm === true) {
+    // One-call shortcut: approve the just-minted confirmation, then let the create consume it.
+    await api.post(`/api/v1/confirmations/${id}/decide`, { decision: 'approve' });
+    return { query: `?confirmationId=${encodeURIComponent(id)}` };
+  }
+  return {
+    requiresConfirmation: true,
+    cost,
+    priceBook: orgId ? `org:${orgId}` : 'global-defaults',
+    confirmationId: id,
+    message: `Billable ${kind} — show the user this cost, then approve server-side: neo_confirm_action("${id}", "approve"), and re-call this tool with confirmationId="${id}". (Shortcut: re-call with confirm:true.) Nothing was created.`,
+  };
+}
+
 const SECRET_KEY = /(password|secret|secretkey|accesskey|connectionstring|connstr|dsn|token|privatekey|apikey|authorization)/i;
 // Deployment snapshots (exact keys) embed rendered configs with plaintext creds — a
 // queue's `--pass`, a DB's POSTGRES_PASSWORD. Redact by EXACT key so we don't also
@@ -614,7 +661,7 @@ export const TOOLS = [
   {
     name: 'neo_deploy_folder',
     description:
-      'Deploy a local folder or .zip in a project (built server-side). The path is on the machine running this MCP server. Pick the environment with `environment` (JNG #72). Pick the service type with `serviceType`: web (default), worker (background job, no public URL), or static_site; a plainly-static folder auto-detects as static_site. A worker is never given a public port/ingress; its type is never silently changed on redeploy (handoff 4.2/4.3).',
+      'Deploy a local folder or .zip in a project (built server-side). The path is on the machine running this MCP server. COST GATE (mandatory): a billable deploy requires a confirmToken — call once to get the cost + confirmToken (returns status:requires_confirmation, deploys nothing), show the user, then re-call with that confirmToken to deploy. Pick the environment with `environment` (JNG #72). Pick the service type with `serviceType`: web (default), worker (background job, no public URL), or static_site; a plainly-static folder auto-detects as static_site. A worker is never given a public port/ingress; its type is never silently changed on redeploy (handoff 4.2/4.3).',
     mutating: true,
     schema: {
       type: 'object',
@@ -629,6 +676,7 @@ export const TOOLS = [
         environment: { type: 'string', enum: ['staging', 'production'], description: 'REQUIRED — staging or production. Never defaulted (handoff §2). Deploy to staging first.' },
         dryRun: { type: 'boolean', description: 'Preview the plan without creating/uploading/deploying anything (JNG #93). Returns a confirmToken.' },
         confirmToken: str('The confirmToken from a prior dryRun — pass it on the real deploy to guarantee the spec/cost the user approved has not changed (rejected on mismatch).'),
+        confirm: { type: 'boolean', description: 'Approve the billable deploy after showing the user the cost (alternative to confirmToken). Without confirmToken or confirm:true the tool returns the cost and deploys nothing.' },
       },
       required: ['projectId', 'path', 'environment'],
     },
@@ -654,9 +702,10 @@ export const TOOLS = [
         port: args.port,
         environment,
         confirmToken: args.confirmToken,
+        confirm: args.confirm === true,
         dryRun: !!args.dryRun,
       });
-      if (r.dryRun) return { status: 'dry_run', plan: r.plan, service: r.service, environment: r.environment, estimatedCost: r.estimatedCost, confirmToken: r.confirmToken, note: 'To deploy exactly this, re-call without dryRun and pass this confirmToken.' };
+      if (r.dryRun) return { status: r.requiresConfirmation ? 'requires_confirmation' : 'dry_run', requiresConfirmation: r.requiresConfirmation || undefined, plan: r.plan, service: r.service, environment: r.environment, estimatedCost: r.estimatedCost, confirmToken: r.confirmToken, note: r.note || 'To deploy exactly this, re-call without dryRun and pass this confirmToken.' };
       if (r.pending) return { status: 'pending_approval', approvalId: r.approvalId };
       return { status: r.result, url: r.url || undefined, appId: r.appId };
     },
@@ -696,22 +745,23 @@ export const TOOLS = [
         volumeSize: str('Storage size, e.g. "10Gi" (optional)'),
         replicas: int('Read/failover replicas for HA (optional; postgres/CNPG only)'),
         deploymentMode: { type: 'string', description: 'single | ha (optional)' },
-        confirm: { type: 'boolean', description: 'Approve & Create: without confirm:true the tool returns the cost and creates nothing. Re-call with confirm:true to actually create.' },
+        confirm: { type: 'boolean', description: 'Approve & Create in one call: mints + auto-approves a server-side billable confirmation, then creates. Without confirm (or confirmationId) the tool returns the cost + a pending confirmationId and creates nothing.' },
+        confirmationId: str('An APPROVED billable_create confirmation id (from neo_confirm_action) — re-call with it to create. Alternative to confirm:true.'),
       },
       required: ['projectId', 'name', 'engine', 'environment'],
     },
     async call(api, args) {
       requireEnv(args.environment);
-      const gate = await confirmCost(api, args, { storageGB: gbFromSize(args.volumeSize), replicas: args.replicas });
-      if (gate) return gate;
-      const { projectId, confirm, orgId, ...body } = args;
-      const { status, data } = await api.post(`/api/v1/projects/${projectId}/databases`, body);
+      const gate = await billableGate(api, { projectId: args.projectId, kind: 'database', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm }, { storageGB: gbFromSize(args.volumeSize), replicas: args.replicas });
+      if (gate.requiresConfirmation) return gate;
+      const { projectId, confirm, confirmationId, orgId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/databases${gate.query}`, body);
       return redactSecrets(result(status, data));
     },
   },
   {
     name: 'neo_deploy_database',
-    description: 'Deploy an individually-created managed database so it actually runs (provisions the cluster, sets its private host/port). Required after neo_create_database before the DB is reachable, bindable, or can have public access enabled. Poll neo_get_database until host is set and neo_verify_database passes. Credentials redacted.',
+    description: 'Deploy an individually-created managed database so it actually runs (provisions the cluster, sets its private host/port). Required after neo_create_database before the DB is reachable, bindable, or can have public access enabled. For CNPG postgres this returns ready:false — the Cluster is created but initdb runs ~1-3 min and SQL is NOT reachable yet; the deployment status stays "running" and flips to "success" when a ready instance comes up. Do NOT treat the response as terminal: poll neo_verify_database until it passes (authoritative SQL round-trip) before connecting/binding. Credentials redacted.',
     mutating: true,
     schema: { type: 'object', properties: { databaseId: str('Database id (from neo_create_database)') }, required: ['databaseId'] },
     async call(api, args) {
@@ -866,16 +916,17 @@ export const TOOLS = [
         environment: { type: 'string', enum: ['staging', 'production'], description: 'REQUIRED — staging or production (never defaulted, handoff §2)' },
         volumeSize: str('Storage size, e.g. "10Gi" (optional)'),
         dlqEnabled: { type: 'boolean', description: 'Enable a dead-letter queue (optional, default true). Pass false to disable — this is now honored.' },
-        confirm: { type: 'boolean', description: 'Approve & Create: without confirm:true the tool returns the cost and creates nothing. Re-call with confirm:true to actually create.' },
+        confirm: { type: 'boolean', description: 'Approve & Create in one call: mints + auto-approves a server-side billable confirmation, then creates. Without confirm (or confirmationId) the tool returns the cost + a pending confirmationId and creates nothing.' },
+        confirmationId: str('An APPROVED billable_create confirmation id (from neo_confirm_action) — re-call with it to create. Alternative to confirm:true.'),
       },
       required: ['projectId', 'name', 'environment'],
     },
     async call(api, args) {
       requireEnv(args.environment);
-      const gate = await confirmCost(api, args, { storageGB: gbFromSize(args.volumeSize) });
-      if (gate) return gate;
-      const { projectId, confirm, orgId, ...body } = args;
-      const { status, data } = await api.post(`/api/v1/projects/${projectId}/queues`, body);
+      const gate = await billableGate(api, { projectId: args.projectId, kind: 'queue', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm }, { storageGB: gbFromSize(args.volumeSize) });
+      if (gate.requiresConfirmation) return gate;
+      const { projectId, confirm, confirmationId, orgId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/queues${gate.query}`, body);
       return redactSecrets(result(status, data));
     },
   },
@@ -1003,20 +1054,21 @@ export const TOOLS = [
         retryCount: int('Retries on failure (optional) → backoffLimit'),
         concurrencyPolicy: { type: 'string', enum: ['Allow', 'Forbid', 'Replace'], description: 'Overlap policy if a run is still going when the next is due (optional, default Allow)' },
         environment: { type: 'string', enum: ['staging', 'production'], description: 'REQUIRED — staging or production (never defaulted, handoff §2)' },
-        confirm: { type: 'boolean', description: 'Approve & Create: without confirm:true the tool returns the cost (crons are billed per run — variable) and creates nothing. Re-call with confirm:true to create.' },
+        confirm: { type: 'boolean', description: 'Approve & Create in one call: mints + auto-approves a server-side billable confirmation (crons are billed per run — variable), then creates. Without confirm (or confirmationId) the tool returns the cost + a pending confirmationId and creates nothing.' },
+        confirmationId: str('An APPROVED billable_create confirmation id (from neo_confirm_action) — re-call with it to create. Alternative to confirm:true.'),
       },
       required: ['projectId', 'name', 'mode', 'scheduleType', 'environment'],
     },
     async call(api, args) {
       requireEnv(args.environment);
-      const gate = await confirmCost(api, args, {}); // cron cost is variable (per-run) — gate surfaces the rate
-      if (gate) return gate;
+      const gate = await billableGate(api, { projectId: args.projectId, kind: 'cron', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm }, {}); // cron cost is variable (per-run) — gate surfaces the rate
+      if (gate.requiresConfirmation) return gate;
       // Merge contentType into headers for convenience (unless already set).
       if (args.contentType) {
         args = { ...args, headers: { 'Content-Type': args.contentType, ...(args.headers || {}) } };
       }
-      const { projectId, confirm, orgId, contentType, ...body } = args;
-      const { status, data } = await api.post(`/api/v1/projects/${projectId}/crons`, body);
+      const { projectId, confirm, confirmationId, orgId, contentType, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/crons${gate.query}`, body);
       return redactSecrets(result(status, data));
     },
   },
@@ -1069,15 +1121,16 @@ export const TOOLS = [
         region: str('Region (optional; see neo_list_regions on the portal)'),
         acl: { type: 'string', description: 'private | public-read (optional, default private)' },
         quotaGB: int('Storage quota in GB (optional)'),
-        confirm: { type: 'boolean', description: 'Approve & Create: without confirm:true the tool returns the cost and creates nothing. Re-call with confirm:true to actually create.' },
+        confirm: { type: 'boolean', description: 'Approve & Create in one call: mints + auto-approves a server-side billable confirmation, then creates. Without confirm (or confirmationId) the tool returns the cost + a pending confirmationId and creates nothing.' },
+        confirmationId: str('An APPROVED billable_create confirmation id (from neo_confirm_action) — re-call with it to create. Alternative to confirm:true.'),
       },
       required: ['projectId', 'name'],
     },
     async call(api, args) {
-      const gate = await confirmCost(api, args, { objectStorageGB: gbFromSize(args.quotaGB) });
-      if (gate) return gate;
-      const { projectId, confirm, orgId, ...body } = args;
-      const { status, data } = await api.post(`/api/v1/projects/${projectId}/buckets`, body);
+      const gate = await billableGate(api, { projectId: args.projectId, kind: 'bucket', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm }, { objectStorageGB: gbFromSize(args.quotaGB) });
+      if (gate.requiresConfirmation) return gate;
+      const { projectId, confirm, confirmationId, orgId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/buckets${gate.query}`, body);
       return redactSecrets(result(status, data));
     },
   },
@@ -1402,15 +1455,21 @@ export const TOOLS = [
       if (args.confirmationId) {
         return deleteAndConverge(api, `/api/v1/apps/${args.appId}`, args.appId, 'service', `?confirmationId=${encodeURIComponent(args.confirmationId)}`);
       }
+      // GET /apps/{id} returns { application: {...} }, so unwrap it — reading .data directly
+      // left every field undefined and the preview showed service:{} (retest B).
       let svc = null;
-      try { svc = (await api.get(`/api/v1/apps/${args.appId}`)).data; } catch { /* preview best-effort */ }
+      try { const d = (await api.get(`/api/v1/apps/${args.appId}`)).data; svc = (d && d.application) || d; } catch { /* preview best-effort */ }
       let c;
       try { c = (await api.post('/api/v1/confirmations', { action: 'service_delete', targetId: args.appId })).data; }
       catch (e) { return { deleted: false, error: 'confirmation_failed', message: 'Could not create a deletion confirmation: ' + (e.message || e) }; }
-      const phrase = (c.summary && c.summary.phraseRequired) || (svc && svc.name);
+      // Prefer the server confirmation's authoritative identity (what neo_get_confirmation shows);
+      // fall back to the unwrapped GET, then to just the id.
+      const svcView = (c.summary && c.summary.service) ||
+        (svc ? { id: svc.id, name: svc.name, type: svc.serviceType, environment: svc.environment } : { id: args.appId });
+      const phrase = (c.summary && c.summary.phraseRequired) || svcView.name;
       return {
         deleted: false, requiresConfirmation: true,
-        service: svc ? { id: svc.id, name: svc.name, type: svc.serviceType, environment: svc.environment } : { id: args.appId },
+        service: svcView,
         warning: 'IRREVERSIBLE: deletes the service and tears down its running workload.',
         confirmationId: c.confirmationId, phraseRequired: phrase,
         message: `To delete: call neo_confirm_action("${c.confirmationId}", "approve", confirmationPhrase="${phrase}") — the human must type the exact service name — then re-call neo_delete_service with confirmationId="${c.confirmationId}".`,