@biznetgio/neo-app 0.4.70 → 0.4.74

package/package.json

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

package/prompt.md

@@ -6,7 +6,7 @@ Keep this in sync with cli/prompt.md (the npm package's bundled copy).
 -->
 # Set this repo up on NEO App
 
-**Version:** 0.4.5 · **Last updated:** 2026-10-15
+**Version:** 0.4.74 · **Last updated:** 2026-11-05
 
 These are the official setup instructions from NEO App (Biznet Gio's managed-app
 platform). If you are an AI coding agent, complete the steps below yourself by running
@@ -17,7 +17,7 @@ into chat, repository files, the skill, or MCP configuration.
 ## What NEO App runs
 
 Web services, background workers, scheduled jobs, static sites, managed databases
-(PostgreSQL/MySQL/…), queues (NATS), and object storage — on managed Kubernetes, served
+(PostgreSQL/MySQL/Redis), queues (NATS), and object storage — on managed Kubernetes, served
 over HTTPS with automatic TLS. It is **not** for GPU training or for apps that need
 several containers running side by side at runtime (a single app container alongside
 managed databases is fine). If the repo has no server to put behind a URL (a library or
@@ -118,7 +118,8 @@ tools — never the portal UI. The lifecycle is the same for every resource type
    components in a monorepo. Ask the human which to deploy; never collapse a monorepo
    into one service.
 2. **Plan and show the cost**: `neo_plan_stack` returns an immutable, priced plan
-   (`planId`, `planHash`, cost in IDR, expiry). Show the human the cost and get an
+   (`planId`, `planHash`, cost in IDR with monthly and hourly totals, expiry). Show
+   the human the cost and get an
    explicit **Approve & Create**. Individual creates (`neo_create_database`,
    `neo_create_queue`) instead return the cost and create nothing until you re-call
    with `confirm: true`.

package/src/commands/deploy.js

@@ -35,6 +35,9 @@ function showCost(r) {
     const e = r.estimatedCost;
     const note = (e.assumptions || []).join('; ');
     log(c.bold(`Estimated cost: ${formatCost(e)}`) + (note ? c.dim(` — ${note}`) : ''));
+    // Identify the exact price-book snapshot the quote (and any approval) is pinned to (#170 r18a D1).
+    const ver = e.priceBookVersion || r.priceBookVersion;
+    if (ver) log(c.dim(`  price book: ${ver}`));
   }
 }
 
@@ -95,6 +98,16 @@ export async function deploy(source, opts = {}) {
     log: step,
   };
 
+  // --json: machine-readable + non-interactive. A real deploy still requires --yes; otherwise
+  // deploySource returns the priced gate (requiresConfirmation + estimatedCost + confirmToken)
+  // and deploys nothing. One shape, mirroring the MCP cost schema (#170).
+  if (opts.json) {
+    const r = await deploySource(api, { ...base, log: () => {}, dryRun, confirm: !!opts.yes });
+    process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+    if (r.result && r.result !== 'success' && !r.dryRun && !r.requiresConfirmation && !r.pending) process.exitCode = 1;
+    return r;
+  }
+
   // 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

package/src/commands/estimate.js

@@ -0,0 +1,82 @@
+// `neo-app estimate` — a read-only cost quote from the server's authoritative price book
+// (#170 r18a D2). Works WITHOUT a project (org-scoped), unlike `deploy --dry-run` which
+// needs one, so a vibe coder can price a resource before creating anything. Zero-write.
+
+import { resolveConfig } from '../config.js';
+import { getCredential } from '../creds.js';
+import { NeoApi } from '../api.js';
+import { readLink } from '../link.js';
+import { specToResources, formatCost } from '../cost.js';
+import { log, ok, fail, c } from '../util.js';
+
+// buildSpec turns the CLI flags into the flat cost spec specToResources understands.
+function buildSpec(opts) {
+  const spec = {};
+  if (opts.tier) spec.computeTier = opts.tier;
+  if (opts.vcpu) spec.vcpu = Number(opts.vcpu);
+  if (opts.mem) spec.memoryMB = Number(opts.mem);
+  if (opts.storage) spec.storageGB = Number(opts.storage);
+  if (opts.object) spec.objectStorageGB = Number(opts.object);
+  if (opts.replicas) spec.replicas = Number(opts.replicas);
+  if (opts.queue) spec.queue = true;
+  if (opts.cron) spec.cron = true;
+  return spec;
+}
+
+export async function estimate(opts = {}) {
+  const cfg = resolveConfig(opts);
+  const cred = getCredential(cfg.baseUrl);
+  if (!cred?.token) {
+    fail(`not authenticated for ${cfg.baseUrl} — run 'neo-app login'`);
+    process.exit(1);
+  }
+  const api = new NeoApi({ baseUrl: cfg.baseUrl, token: cred.token });
+
+  const spec = buildSpec(opts);
+  const resources = specToResources(spec);
+  if (!resources.length) {
+    fail('nothing to estimate — pass --tier <micro|small|…> (or --vcpu N --mem MB), --storage GB, --object GB, --queue, or --cron');
+    process.exit(2);
+  }
+
+  // Scope: an explicit/linked project (exact org context) else the account's org — the
+  // server authority is the same, so a project-less quote still works.
+  const projectId = opts.project || readLink()?.projectId;
+  let scope;
+  if (projectId) scope = { projectId };
+  else {
+    let orgId = opts.org;
+    if (!orgId) { try { orgId = await api.resolveOrgId(); } catch { orgId = null; } }
+    if (!orgId) { fail('no project or organization — run \'neo-app login\', or pass --project <id> / --org <id>'); process.exit(1); }
+    scope = { orgId };
+  }
+
+  let cost;
+  try {
+    cost = (await api.estimate(scope, { resources })).cost;
+  } catch (e) {
+    fail(`estimate failed: ${e.message || e}`);
+    process.exit(1);
+  }
+
+  // Fail closed when the server can't price a metric (#170: never quote at a guessed rate).
+  if (cost?.pricingUnavailable?.length) {
+    if (opts.json) process.stdout.write(JSON.stringify({ cost }, null, 2) + '\n');
+    fail(`pricing unavailable for: ${cost.pricingUnavailable.join(', ')} — cannot quote`);
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ cost }, null, 2) + '\n');
+    return cost;
+  }
+
+  log(c.bold(`Estimated cost: ${formatCost(cost)}`));
+  for (const l of cost.breakdown || []) log(`  · ${l.item}: ${l.monthly} ${cost.currency}/mo (${l.hourly}/h)`);
+  for (const u of cost.upfront || []) log(`  · ${u.item}: ${u.monthly} ${cost.currency} upfront (hourly: n/a)`);
+  for (const v of cost.variable || []) log(c.dim(`  usage: ${v.rate} ${cost.currency}/${v.unit || v.metric}`));
+  if (cost.priceBookVersion) log(c.dim(`  price book: ${cost.priceBookVersion} · billing quantum: ${cost.billingQuantum || 'hour'}`));
+  for (const a of cost.assumptions || []) log(c.dim(`  assumption: ${a}`));
+  ok('estimate complete — nothing was created');
+  return cost;
+}

package/src/cost.js

@@ -26,6 +26,13 @@ export function specToResources(spec = {}) {
   }
   if (spec.storageGB) resources.push({ kind: 'database', name: 'storage', volumeSize: `${spec.storageGB}Gi` });
   if (spec.objectStorageGB) resources.push({ kind: 'bucket', name: 'object', quotaGB: spec.objectStorageGB });
+  // A cron has no fixed cost — it's billed per run. The server returns it as a 0 fixed
+  // line plus the `cron_run` rate in `variable[]`, which is what the gate surfaces (#170).
+  if (spec.cron) resources.push({ kind: 'cron', name: 'cron' });
+  // A queue bills ONLY per message (queue_message) — never compute/storage (JNG #52). It is
+  // its OWN kind, not a database: mapping queue storage to a `database` resource priced it as
+  // DB compute+storage and mislabeled it "database storage" (#170 r18a D5).
+  if (spec.queue) resources.push({ kind: 'queue', name: 'queue' });
   return resources;
 }
 

package/src/index.js

@@ -16,11 +16,13 @@ ${c.bold('Commands')}
   login                    Authenticate with a NEO App API key (kap_...)
   link <project-id>        Link this repo to a project (writes .neo-app.json)
   deploy [path|.zip|git-url]   Deploy a directory (default: cwd), a .zip, a Git repo, or --image <ref>
+  estimate                 Price a resource from the server price book (read-only; no project needed)
                            (or pass the same via --source <path|.zip|git-url>)
   project create [name]    Create a project (defaults to the dir name) and link it
   project list             List projects in your organization (find ids to link)
   status | whoami          Show connected account, org, environment, linked project
-  mcp                      Run the local stdio MCP server (used by agents)
+  mcp                      Run the MCP server: local stdio (default), or hosted
+                           Streamable HTTP + SSE with --http [--port <n>] [--host <h>]
 
 ${c.bold('Options')}
   --project <id>           Target/link a project (agent setup, deploy)
@@ -35,6 +37,13 @@ ${c.bold('Options')}
   --token <kap_...>        API key (also NEO_APP_TOKEN; prompted if omitted)
   --yes                    Non-interactive (headless/CI); also approves a billable deploy without the cost prompt
   --dry-run               Print intended changes without writing
+  --json                   Machine-readable output incl. the normalized cost (deploy, estimate)
+  --tier <key>             estimate: compute tier (micro|small|medium|large|xlarge)
+  --vcpu <n> --mem <MB>    estimate: custom compute (instead of --tier)
+  --storage <GB>           estimate: database/persistent storage
+  --object <GB>            estimate: object-storage quota (billed monthly-upfront)
+  --queue / --cron         estimate: a queue (per-message) / cron (per-run) resource
+  --replicas <n>           estimate: replica count
   -v, --version           Print version
   -h, --help              Show this help`;
 
@@ -63,6 +72,18 @@ const options = {
   prod: { type: 'boolean' },
   yes: { type: 'boolean' },
   'dry-run': { type: 'boolean' },
+  json: { type: 'boolean' },
+  tier: { type: 'string' },
+  vcpu: { type: 'string' },
+  mem: { type: 'string' },
+  storage: { type: 'string' },
+  object: { type: 'string' },
+  replicas: { type: 'string' },
+  queue: { type: 'boolean' },
+  cron: { type: 'boolean' },
+  http: { type: 'boolean' },
+  sse: { type: 'boolean' },
+  host: { type: 'string' },
   version: { type: 'boolean', short: 'v' },
   help: { type: 'boolean', short: 'h' },
 };
@@ -85,7 +106,7 @@ export async function main(argv = process.argv.slice(2)) {
   // Root help, and `--help` on a KNOWN command, print usage. An UNKNOWN command must
   // still error (nonzero exit) even with `--help`, so a bad command isn't silently
   // accepted (JNG #97). Per-subcommand help is tracked in #89.
-  const KNOWN_COMMANDS = new Set(['agent', 'setup', 'config', 'login', 'deploy', 'link', 'project', 'status', 'whoami', 'mcp', 'version', 'help']);
+  const KNOWN_COMMANDS = new Set(['agent', 'setup', 'config', 'login', 'deploy', 'estimate', 'link', 'project', 'status', 'whoami', 'mcp', 'version', 'help']);
   if (positionals.length === 0 || (opts.help && KNOWN_COMMANDS.has(cmd))) return void console.log(HELP);
 
   try {
@@ -96,12 +117,18 @@ export async function main(argv = process.argv.slice(2)) {
     if (cmd === 'config' && sub === 'install-mcp') return void (await (await import('./commands/install-mcp.js')).installMcp(opts));
     if (cmd === 'login') return void (await (await import('./commands/login.js')).login(opts));
     if (cmd === 'deploy') return void (await (await import('./commands/deploy.js')).deploy(sub, opts));
+    if (cmd === 'estimate') return void (await (await import('./commands/estimate.js')).estimate(opts));
     if (cmd === 'link') return void (await (await import('./commands/link.js')).link(sub, opts));
     if (cmd === 'project' && sub === 'link') return void (await (await import('./commands/link.js')).link(positionals[2], opts));
     if (cmd === 'project' && sub === 'create') return void (await (await import('./commands/link.js')).createProject(positionals[2], opts));
     if (cmd === 'project' && (sub === 'list' || sub === 'ls')) return void (await (await import('./commands/link.js')).listProjects(opts));
     if (cmd === 'status' || cmd === 'whoami') return void (await (await import('./commands/status.js')).status(opts));
-    if (cmd === 'mcp') return void (await (await import('./mcp/server.js')).runMcpServer());
+    if (cmd === 'mcp') {
+      const mcp = await import('./mcp/server.js');
+      // Hosted mode: Streamable HTTP + SSE over one listener (auth per request). Default: stdio.
+      if (opts.http || opts.sse || opts.port) return void (await mcp.runMcpHttpServer({ port: opts.port, host: opts.host }));
+      return void (await mcp.runMcpServer());
+    }
     if (cmd === 'version') return void console.log(version());
     if (cmd === 'help') return void console.log(HELP);
 

package/src/mcp/server.js

@@ -1,10 +1,19 @@
-// NEO App local stdio MCP server (`neo-app mcp`). Reuses the authenticated CLI
-// credential for the configured control-plane — the token is NEVER passed in agent
-// config, it is read here from the credential store (or NEO_APP_TOKEN). All logging
-// goes to stderr; stdout is the JSON-RPC channel.
+// NEO App MCP server. ONE tool registry (./tools.js, the canonical neo_* contract) served
+// over three transports so every surface is capability- and version-identical (#175):
+//   • stdio  (`neo-app mcp`)          — local agent, reuses the authenticated CLI credential.
+//   • Streamable HTTP (`mcp --http`)  — hosted, STATELESS (fresh server+transport per POST,
+//                                       JSON responses), auth from the request's Bearer token.
+//                                       Stateless keeps it multi-replica-safe and lets the
+//                                       control plane front it per-request (it owns sessions).
+//   • SSE  (same `--http` listener)   — hosted, session per connection (for direct clients).
+// serverInfo.version is the packed npm version for every transport (never "docker").
+// All logging goes to stderr; stdout is the stdio JSON-RPC channel.
 
+import { createServer as createHttpServer } from 'node:http';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { resolveConfig } from '../config.js';
 import { getCredential } from '../creds.js';
@@ -12,16 +21,10 @@ import { NeoApi } from '../api.js';
 import { pkgVersion } from '../util.js';
 import { TOOLS } from './tools.js';
 
-export async function runMcpServer() {
-  const cfg = resolveConfig({});
-  const cred = getCredential(cfg.baseUrl);
-  const api = new NeoApi({ baseUrl: cfg.baseUrl, token: cred?.token });
-  if (!cred?.token) {
-    console.error(`[neo-app mcp] no credential for ${cfg.baseUrl} — run 'neo-app login' or set NEO_APP_TOKEN`);
-  }
-
-  // serverInfo.version MUST equal the packed npm artifact version (handoff 3.1):
-  // derive it from package.json, never hard-code it.
+// buildServer wires the shared tool registry onto a fresh MCP Server bound to ONE NeoApi
+// (one session's auth token + env pin). Every transport reuses it, so stdio and hosted
+// HTTP/SSE serve the identical neo_* contract, annotations, and version (#175 parity).
+function buildServer(api) {
   const server = new Server({ name: 'neo-app', version: pkgVersion() }, { capabilities: { tools: {} } });
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -40,7 +43,7 @@ export async function runMcpServer() {
     }
     if (!api.token) {
       return {
-        content: [{ type: 'text', text: 'Not authenticated. Run `neo-app login` or set NEO_APP_TOKEN.' }],
+        content: [{ type: 'text', text: 'Not authenticated. Send an Authorization: Bearer <kap_ token> header (hosted), run `neo-app login`, or set NEO_APP_TOKEN (stdio).' }],
         isError: true,
       };
     }
@@ -54,6 +57,104 @@ export async function runMcpServer() {
     }
   });
 
+  return server;
+}
+
+// runMcpServer: local stdio. One process = one local credential (unchanged behavior).
+export async function runMcpServer() {
+  const cfg = resolveConfig({});
+  const cred = getCredential(cfg.baseUrl);
+  const api = new NeoApi({ baseUrl: cfg.baseUrl, token: cred?.token });
+  if (!cred?.token) {
+    console.error(`[neo-app mcp] no credential for ${cfg.baseUrl} — run 'neo-app login' or set NEO_APP_TOKEN`);
+  }
+  // serverInfo.version MUST equal the packed npm artifact version (handoff 3.1): buildServer
+  // derives it from package.json.
+  const server = buildServer(api);
   await server.connect(new StdioServerTransport());
-  console.error(`[neo-app mcp] ready: ${cfg.env} ${cfg.baseUrl}`);
+  console.error(`[neo-app mcp] ready: ${cfg.env} ${cfg.baseUrl} — ${TOOLS.length} tools v${pkgVersion()}`);
+}
+
+const bearer = (req) => {
+  const m = /^Bearer\s+(.+)$/i.exec(req.headers['authorization'] || '');
+  return m ? m[1].trim() : null;
+};
+
+// runMcpHttpServer: hosted Streamable HTTP + SSE. The agent's per-request Bearer token
+// becomes that session's NeoApi token — NEVER a local credential. baseUrl is the control
+// plane this MCP fronts (config / NEO_APP_URL). Returns the http.Server (for tests).
+export async function runMcpHttpServer({ port, host } = {}) {
+  const cfg = resolveConfig({});
+  // Honor an explicit port, including 0 (ephemeral, used by tests); else PORT, else 8750.
+  const listenPort = (port != null && port !== '') ? Number(port) : Number(process.env.PORT || 8750);
+  const listenHost = host || process.env.HOST || '0.0.0.0';
+  // Mount point for the MCP routes. Default '/mcp'; set NEO_APP_MCP_BASE_PATH=/api/v1/mcp
+  // when the control plane reverse-proxies that public path straight through to this sidecar,
+  // so the SSE "endpoint" event the client is told to POST back to resolves correctly.
+  const base = (process.env.NEO_APP_MCP_BASE_PATH || '/mcp').replace(/\/+$/, '');
+  const apiFor = (req) => new NeoApi({ baseUrl: cfg.baseUrl, token: bearer(req) });
+
+  // SSE keeps per-connection state in-process (sessionId -> transport); the agent's Bearer
+  // token is bound to the session's NeoApi when the stream opens. Streamable HTTP is stateless
+  // (no map). ponytail: the SSE map → run as a SINGLE replica; add sticky routing or a shared
+  // store before scaling SSE horizontally. Streamable HTTP has no such limit.
+  const sseSessions = new Map();  // sessionId -> SSEServerTransport
+
+  const json = (res, code, obj) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(obj)); };
+
+  const httpServer = createHttpServer(async (req, res) => {
+    try {
+      const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+
+      // Unauthenticated liveness/capability probe so infra can confirm the hosted MCP is up
+      // and advertises the full contract (version + tool count) — the opposite of the #175
+      // "connected but silently reduced" failure.
+      if (req.method === 'GET' && (url.pathname === '/healthz' || url.pathname === '/version')) {
+        return json(res, 200, { component: 'neo-app-mcp', version: pkgVersion(), tools: TOOLS.length, transports: ['streamable-http', 'sse'] });
+      }
+
+      // --- Streamable HTTP (stateless): a fresh server + transport per POST, JSON responses.
+      // Each request is self-contained (the SDK answers tools/list without a prior initialize),
+      // so no session id is minted here — the control plane fronting this owns session state. ---
+      if (url.pathname === base) {
+        if (req.method !== 'POST') {
+          res.setHeader('allow', 'POST');
+          return json(res, 405, { error: 'method not allowed; stateless Streamable HTTP MCP uses POST' });
+        }
+        const server = buildServer(apiFor(req));
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+        res.on('close', () => { transport.close(); server.close(); });
+        await server.connect(transport);
+        await transport.handleRequest(req, res); // SDK reads the JSON-RPC body from the stream
+        return;
+      }
+
+      // --- SSE (stateful): GET <base>/sse opens the stream, POST <base>/messages carries messages ---
+      if (url.pathname === `${base}/sse` && req.method === 'GET') {
+        const server = buildServer(apiFor(req));
+        const transport = new SSEServerTransport(`${base}/messages`, res);
+        sseSessions.set(transport.sessionId, transport);
+        res.on('close', () => { sseSessions.delete(transport.sessionId); server.close(); });
+        await server.connect(transport); // calls transport.start() → sends the endpoint event
+        return;
+      }
+      if (url.pathname === `${base}/messages` && req.method === 'POST') {
+        const transport = sseSessions.get(url.searchParams.get('sessionId'));
+        if (!transport) return json(res, 404, { error: 'no such SSE session' });
+        await transport.handlePostMessage(req, res);
+        return;
+      }
+
+      return json(res, 404, { error: 'not found' });
+    } catch (e) {
+      console.error('[neo-app mcp] request error', e?.message || e);
+      if (!res.headersSent) json(res, 500, { error: String(e?.message || e) });
+      else try { res.end(); } catch { /* already closed */ }
+    }
+  });
+
+  await new Promise((resolve) => httpServer.listen(listenPort, listenHost, resolve));
+  const boundPort = httpServer.address()?.port ?? listenPort;
+  console.error(`[neo-app mcp] hosted ready: http://${listenHost}:${boundPort}${base} (streamable) + ${base}/sse — fronting ${cfg.baseUrl}, ${TOOLS.length} tools v${pkgVersion()}`);
+  return httpServer;
 }

package/src/mcp/tools.js

@@ -31,10 +31,14 @@ function result(status, data) {
 // §2 safety: a create/deploy mutation must name its environment explicitly —
 // NEVER default to production. A silent prod mutation is the exact risk the
 // handoff calls out ("Never default a missing environment to production").
-// sessionEnv pins ONE target environment (staging|production) for this MCP session so an
-// agent doesn't mix staging and production within a task (JNG #136). Seeded from
-// NEO_APP_TARGET_ENV; set at runtime with neo_set_context. null = not chosen yet.
-let sessionEnv = (() => { const e = String(process.env.NEO_APP_TARGET_ENV || '').toLowerCase(); return (e === 'staging' || e === 'production') ? e : null; })();
+// The session env pin (JNG #136) is PER-API-SESSION state, not a module global, so one
+// hosted MCP process can serve many tenants concurrently without their env pins bleeding
+// across sessions — each MCP session has its own NeoApi, and the pin lives on it. Stdio
+// has a single api for the whole process, so the behavior is identical to a module global.
+// Seeded once per api from NEO_APP_TARGET_ENV; null = not chosen yet.
+function seedSessionEnv() { const e = String(process.env.NEO_APP_TARGET_ENV || '').toLowerCase(); return (e === 'staging' || e === 'production') ? e : null; }
+function getSessionEnv(api) { if (api._sessionEnv === undefined) api._sessionEnv = seedSessionEnv(); return api._sessionEnv; }
+function setSessionEnv(api, v) { api._sessionEnv = v; }
 
 // envStrict validates an explicit staging|production value (no fallback).
 function envStrict(env) {
@@ -48,36 +52,39 @@ function envStrict(env) {
 // call), a later call for a DIFFERENT environment is refused unless allowCrossEnvironment is
 // set — so staging and production can't be mixed in one session. The first explicit choice
 // pins the session so subsequent calls inherit it. Never silently defaulted.
-function requireEnv(env, allowCross = false) {
+function requireEnv(api, env, allowCross = false) {
   const e = String(env || '').toLowerCase();
   const explicit = (e === 'staging' || e === 'production') ? e : null;
-  if (sessionEnv) {
-    if (explicit && explicit !== sessionEnv && !allowCross) {
-      throw new Error(`environment_mismatch: this session is pinned to "${sessionEnv}" but the call requested "${explicit}". Staging and production must not be mixed in one session (JNG #136). Pass allowCrossEnvironment:true to allow this one call, or re-pin with neo_set_context.`);
+  const pinned = getSessionEnv(api);
+  if (pinned) {
+    if (explicit && explicit !== pinned && !allowCross) {
+      throw new Error(`environment_mismatch: this session is pinned to "${pinned}" but the call requested "${explicit}". Staging and production must not be mixed in one session (JNG #136). Pass allowCrossEnvironment:true to allow this one call, or re-pin with neo_set_context.`);
     }
-    return explicit || sessionEnv;
+    return explicit || pinned;
   }
-  if (explicit) { sessionEnv = explicit; return explicit; } // pin the first explicit choice
+  if (explicit) { setSessionEnv(api, explicit); return explicit; } // pin the first explicit choice
   throw new Error('environment_not_chosen: pin it once with neo_set_context({environment:"staging"|"production"}) (ask the user which if unclear; prefer staging), or pass environment explicitly. Never defaulted so staging and production don\'t get mixed (JNG #136).');
 }
 
 // Shared schema fragment: the per-call escape hatch for the session environment pin.
 const allowCrossEnvProp = { allowCrossEnvironment: { type: 'boolean', description: 'Override the session environment pin for THIS call only (JNG #136). A call whose environment differs from the pinned one is refused by default so staging and production are not mixed; set true to allow this one cross-environment action.' } };
 
-// resetSessionEnv clears the session pin. Exported for tests that exercise the pin
-// invariant in sequence (each must start from a clean, unpinned session).
-export function resetSessionEnv() { sessionEnv = null; }
+// resetSessionEnv clears a session's pin. With api-scoped state each test uses a fresh api,
+// so pins never cross tests; kept exported and tolerant of any/no arg for the existing
+// beforeEach(resetSessionEnv) hooks (a no-op when called without a real api).
+export function resetSessionEnv(api) { if (api && typeof api === 'object') api._sessionEnv = null; }
 
 // assertResourceEnv enforces the session pin on an EXISTING resource addressed by id (JNG #136 §4):
 // if the session is pinned and the resource lives in a different environment, refuse so an
 // ID-based op can't touch the wrong environment's resource. allowCrossEnvironment overrides it;
 // resources with no environment (buckets are shared) and an unpinned session are not guarded.
 async function assertResourceEnv(api, getPath, allowCross = false) {
-  if (!sessionEnv || allowCross) return;
+  const pinned = getSessionEnv(api);
+  if (!pinned || allowCross) return;
   let env;
   try { env = (await api.get(getPath)).data?.environment; } catch { return; } // can't resolve → don't block
-  if (env && env !== sessionEnv) {
-    throw new Error(`environment_mismatch: this session is pinned to "${sessionEnv}" but that resource is in "${env}". Staging and production must not be mixed (JNG #136). Pass allowCrossEnvironment:true to act on it anyway, or re-pin with neo_set_context.`);
+  if (env && env !== pinned) {
+    throw new Error(`environment_mismatch: this session is pinned to "${pinned}" but that resource is in "${env}". Staging and production must not be mixed (JNG #136). Pass allowCrossEnvironment:true to act on it anyway, or re-pin with neo_set_context.`);
   }
 }
 
@@ -153,26 +160,33 @@ function validateBucketArgs(args) {
 // args.confirm===true it returns the live-priced cost and creates NOTHING — the
 // agent shows the user, then re-calls with confirm:true. plan/apply remains the
 // server-immutable costed path; this is the lighter client-side gate (handoff 3.3).
-async function confirmCost(api, args, spec) {
+async function confirmCost(api, args, spec, currentSpec) {
   if (args.confirm === true) return null;
   let orgId = null;
   try { orgId = await api.resolveOrgId(args.orgId); } catch { orgId = null; }
   // The server's /estimate is the sole price authority (#170) — the CLI no longer prices
   // locally. Prefer the project scope (exact org context); fall back to org scope for a
-  // project-less quote. Best-effort: a failed estimate must never fail the gate.
-  let cost = null;
+  // project-less quote. When a CURRENT spec is given (a change flow), ask the server for
+  // the delta too (current → proposed → increase). Best-effort: a failed estimate must
+  // never fail the gate.
+  let cost = null, delta = null;
   const resources = specToResources(spec);
+  const current = currentSpec ? specToResources(currentSpec) : null;
   if (resources.length && (args.projectId || orgId)) {
-    try { cost = (await api.estimate(args.projectId ? { projectId: args.projectId } : { orgId }, { resources })).cost; }
-    catch { cost = null; }
+    try {
+      const body = current && current.length ? { resources, current } : { resources };
+      const r = await api.estimate(args.projectId ? { projectId: args.projectId } : { orgId }, body);
+      cost = r.cost; delta = r.delta || null;
+    } catch { cost = null; }
   }
   return {
     requiresConfirmation: true,
     cost,
+    delta, // current → proposed → increase, when a current spec was given (#170 change delta)
     priceBookVersion: cost?.priceBookVersion, // pins the quote to a price-book snapshot (#170)
     acting: await actingOf(api, { orgId, projectId: args.projectId }), // whose/where — JNG #131
     priceBook: cost?.priceBook || (orgId ? `org:${orgId}` : 'global-defaults'),
-    message: 'Billable resource — show the user this cost (and the acting account/org), then re-call with confirm:true to create. For an immutable, server-pinned quote use neo_plan_stack → neo_apply_stack.',
+    message: 'Billable change — show the user BOTH the hourly and monthly cost (and the increase delta, plus any per-use variable rates), then re-call with confirm:true to apply. For an immutable, server-pinned quote use neo_plan_stack → neo_apply_stack.',
   };
 }
 
@@ -194,6 +208,11 @@ async function billableGate(api, { projectId, kind, name, confirmationId, confir
   const resources = specToResources(spec);
   if (resources.length) {
     try { cost = (await api.estimate({ projectId }, { resources })).cost; } catch { cost = null; }
+  } else if (kind === 'database') {
+    // A managed DB is storage-billed only (metering.go/JNG #25); with no volume
+    // there is no fixed cost. Quote Rp0 rather than a bare null (#149 r18a note:
+    // "Redis create returns a null cost estimate") so the gate shows a real figure.
+    cost = { monthly: 0, hourly: 0, currency: 'IDR', note: 'storage-billed only; no volume specified' };
   }
   const costNote = cost ? formatCost(cost) : '';
 
@@ -203,7 +222,7 @@ async function billableGate(api, { projectId, kind, name, confirmationId, confir
   // 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, environment, estimatedCost: costNote, priceBookVersion: cost?.priceBookVersion })).data; break; }
+    try { mint = (await api.post('/api/v1/confirmations', { action: 'billable_create', projectId, kind, name, environment, estimatedCost: costNote, priceBookVersion: cost?.priceBookVersion, cost })).data; break; }
     catch (e) {
       if (attempt < 3 && (e?.status >= 500 || e?.status === 0)) { await new Promise((r) => setTimeout(r, 300 * attempt)); continue; }
       throw e;
@@ -263,8 +282,8 @@ export const TOOLS = [
       required: ['environment'],
     },
     async call(api, args) {
-      sessionEnv = envStrict(args.environment);
-      return { environment: sessionEnv, pinned: true, note: 'Pinned for this session. Env-requiring tools now use it; override per-call by passing environment explicitly.' };
+      setSessionEnv(api, envStrict(args.environment));
+      return { environment: getSessionEnv(api), pinned: true, note: 'Pinned for this session. Env-requiring tools now use it; override per-call by passing environment explicitly.' };
     },
   },
   {
@@ -274,7 +293,7 @@ export const TOOLS = [
     schema: { type: 'object', properties: {} },
     async call(api) {
       const acct = (typeof api.actingIdentity === 'function') ? await api.actingIdentity().catch(() => ({})) : {};
-      return { environment: sessionEnv, ...acct };
+      return { environment: getSessionEnv(api), ...acct };
     },
   },
   {
@@ -310,6 +329,10 @@ export const TOOLS = [
         const v = (await api.get('/version')).data || {};
         controlPlane.version = v.version ?? null;
         controlPlane.gitCommit = v.gitCommit ?? null;
+        // Report the PUBLIC control-plane URL when the server advertises one — the
+        // hosted sidecar reaches the control plane on loopback (127.0.0.1), so
+        // api.baseUrl alone would leak the internal address (#175 r18a retest).
+        if (v.publicUrl) controlPlane.baseUrl = v.publicUrl;
       } catch { /* leave nulls */ }
 
       // Price book is readable by any member; surface whether cost data is
@@ -328,7 +351,7 @@ export const TOOLS = [
         { type: 'template', create: true, deploy: true, scale: false, update: true, logs: true, variables: true, delete: true },
         { type: 'static_site', create: 'via_folder', deploy: true, scale: false, update: true, domains: true, logs: true, variables: true, delete: true, nativeStatic: true, note: 'neo_deploy_folder serviceType=static_site with buildCommand/publishDirectory → native nginx (0.4.27); neo_update_service for domain/tls/path' },
         { type: 'worker', create: 'via_folder', deploy: true, scale: true, update: true, health: true, autoscale: true, logs: true, variables: true, usage: true, delete: true, note: 'neo_deploy_folder serviceType=worker (no public ingress) + neo_update_service (compute/replicas/autoscale/command/health)' },
-        { type: 'database', create: true, deploy: true, get: true, list: true, update: true, backup: true, restore: true, verify: true, publicAccess: true, delete: true, note: 'neo_create/deploy/list/get/update(resize)/delete_database + backup + restore (postgres, local backups) + verify (SQL round-trip) + enable/disable_db_public_access (handoff 4.4)' },
+        { type: 'database', create: true, deploy: true, get: true, list: true, update: true, backup: true, restore: true, verify: true, publicAccess: 'postgres-only', delete: true, engines: ['postgres', 'mysql', 'mariadb', 'redis'], note: 'neo_create/deploy/list/get/update(resize)/delete_database + backup + restore (postgres & mysql/mariadb SQL dumps; redis RDB restores via pod file-swap) + verify (postgres/mysql SQL round-trip, redis SET/GET/TTL/DEL). Managed DBs are storage-billed only (no compute line). publicAccess is postgres-only today; mysql/redis are private-binding only (handoff 4.4, #149).' },
         { type: 'queue', create: true, deploy: true, get: true, list: true, update: true, verify: true, publicAccess: true, delete: true, note: 'neo_create/deploy/list/get/update/verify(publish→persist)/delete_queue + enable/disable_queue_public_access (handoff 4.5)' },
         { type: 'cron', create: true, get: true, list: true, run: true, runs: true, questionnaire: true, delete: true, note: 'neo_cron_questionnaire (guided) + create/list/get/run/list_runs/delete_cron (handoff 4.6)' },
         { type: 'object_storage', create: true, get: true, list: true, objects: true, upload: true, verify: true, delete: true, note: 'neo_create/list/get/verify(put→list→delete)/delete_bucket + list/upload/presign(get)/delete objects (handoff 4.7)' },
@@ -345,7 +368,7 @@ export const TOOLS = [
         sourceTypes: ['git', 'image', 'dockerfile', 'local', 'template'],
         environments: ['staging', 'production'],
         // Active session context + the one-environment-per-session invariant (JNG #136).
-        context: { environment: sessionEnv, pinned: !!sessionEnv },
+        context: { environment: getSessionEnv(api), pinned: !!getSessionEnv(api) },
         environmentIsolation: {
           supported: true,
           pinnedBy: ['neo_set_context', 'first explicit environment on an env-requiring call'],
@@ -499,21 +522,26 @@ export const TOOLS = [
         // effective compute — the one being set, else the service's CURRENT compute. Without
         // the current compute, an autoscale-only change estimated to IDR 0 (#123).
         const replicas = args.replicas ?? args.autoscaleMax ?? args.autoscaleMin;
+        // Read the service's CURRENT compute/storage once — for the empty-tier default (#123)
+        // AND the change delta (current → proposed → increase).
+        let svc = {};
+        try { const d = (await api.get(`/api/v1/apps/${appId}`)).data; svc = (d && d.application) || d || {}; } catch { /* best-effort */ }
+        // A bundled service with no explicit tier bills at the default "micro" (store.DefaultTierKey);
+        // using the empty cpuLimit as-is priced the gate at IDR 0 (#123).
+        const svcSpec = (svc.billingMode === 'unbundled' && (svc.cpuLimit || svc.memoryLimit))
+          ? { vcpu: cpuToVcpu(svc.cpuLimit), memoryMB: memToMB(svc.memoryLimit) }
+          : { computeTier: svc.cpuLimit || 'micro' };
         let spec;
         if (computeTier) spec = { computeTier, replicas };
         else if (args.cpuLimit || args.memoryLimit) spec = { vcpu: cpuToVcpu(args.cpuLimit), memoryMB: memToMB(args.memoryLimit), replicas };
-        else {
-          let svc = {};
-          try { const d = (await api.get(`/api/v1/apps/${appId}`)).data; svc = (d && d.application) || d || {}; } catch { /* best-effort */ }
-          // A bundled service with no explicit tier bills at the default "micro" (store.DefaultTierKey);
-          // using the empty cpuLimit as-is priced the gate at IDR 0 (#123).
-          spec = (svc.billingMode === 'unbundled' && (svc.cpuLimit || svc.memoryLimit))
-            ? { vcpu: cpuToVcpu(svc.cpuLimit), memoryMB: memToMB(svc.memoryLimit), replicas }
-            : { computeTier: svc.cpuLimit || 'micro', replicas };
+        else spec = { ...svcSpec, replicas };
+        const currentSpec = { ...svcSpec, replicas: svc.replicas ?? svc.scaleMin };
+        if (args.volumeSize !== undefined) { // persistent-volume price in the gate (JNG #129)
+          spec = { ...spec, storageGB: gbFromSize(args.volumeSize) };
+          if (svc.volumeSize) currentSpec.storageGB = gbFromSize(svc.volumeSize);
         }
-        if (args.volumeSize !== undefined) spec = { ...spec, storageGB: gbFromSize(args.volumeSize) }; // persistent-volume price in the gate (JNG #129)
-        const gate = await confirmCost(api, args, spec);
-        if (gate) return { ...gate, change: 'update service compute/scaling/volume', message: 'This changes cost — re-call with confirm:true to apply.' };
+        const gate = await confirmCost(api, args, spec, currentSpec);
+        if (gate) return { ...gate, change: 'update service compute/scaling/volume', message: 'This changes cost — show BOTH the hourly and monthly cost and the increase, then re-call with confirm:true to apply.' };
       }
       const { status, data } = await api.put(`/api/v1/apps/${appId}`, body);
       const out = redactSecrets(result(status, data));
@@ -717,7 +745,7 @@ export const TOOLS = [
       required: ['projectId'],
     },
     async call(api, args) {
-      const env = requireEnv(args.environment, args.allowCrossEnvironment);
+      const env = requireEnv(api, args.environment, args.allowCrossEnvironment);
       return { environment: env, ...(await api.get(`/api/v1/projects/${args.projectId}/environments/${env}/config`)).data };
     },
   },
@@ -769,22 +797,22 @@ export const TOOLS = [
   },
   {
     name: 'neo_get_database_metrics',
-    description: 'Current resource usage for a managed postgres database (JNG #133): cpuMillicores + memoryBytes (metrics-server), databaseSizeBytes vs volumeSize (is it filling up?), and connections / maxConnections / connectionsPercent. Snapshot only (no history). Use before a migration or resize to check headroom.',
+    description: 'Current resource usage for a managed database — postgres, mysql/mariadb, or redis (#149). Always: cpuMillicores + memoryBytes (metrics-server). SQL engines: databaseSizeBytes vs volumeSize, connections / maxConnections / connectionsPercent. Redis: usedMemoryBytes / maxMemoryBytes / memoryPercent, connectedClients, keys, opsPerSec, hitRatioPercent, evictedKeys, role. Snapshot only (no history). Use before a migration or resize to check headroom.',
     mutating: false,
-    schema: { type: 'object', properties: { databaseId: str('Database id (postgres, deployed)') }, required: ['databaseId'] },
+    schema: { type: 'object', properties: { databaseId: str('Database id (deployed)') }, required: ['databaseId'] },
     async call(api, args) {
       return (await api.get(`/api/v1/databases/${args.databaseId}/metrics`)).data;
     },
   },
   {
     name: 'neo_db_query',
-    description: 'Run a SQL query inside a managed postgres database\'s primary pod and return the result (JNG #128). READ-ONLY by default (the session is set read-only, so any write errors); pass readOnly:false to allow writes (CAUTION). Credentials are never exposed. The database must be deployed. Use for quick checks like "SELECT count(*) FROM sessions;".',
+    description: 'Run a SQL query inside a managed SQL database\'s primary pod (postgres or mysql/mariadb) and return the result (JNG #128, #149). READ-ONLY by default (the session is set read-only, so any write errors); pass readOnly:false to allow writes (CAUTION). Credentials are never exposed. The database must be deployed. For Redis use neo_redis_command. Use for quick checks like "SELECT count(*) FROM sessions;".',
     mutating: true,
     schema: {
       type: 'object',
       properties: {
-        databaseId: str('Database id (postgres, deployed)'),
-        sql: str('SQL to run (piped into psql)'),
+        databaseId: str('Database id (postgres/mysql, deployed)'),
+        sql: str('SQL to run (piped into the engine client)'),
         readOnly: { type: 'boolean', description: 'true (default) runs in a read-only session; false allows writes' },
         ...allowCrossEnvProp,
       },
@@ -795,6 +823,24 @@ export const TOOLS = [
       return (await api.post(`/api/v1/databases/${args.databaseId}/query`, { sql: args.sql, readOnly: args.readOnly })).data;
     },
   },
+  {
+    name: 'neo_redis_command',
+    description: 'Run a single Redis command inside a managed redis instance\'s pod (safe inspection, #149). Destructive/administrative commands are blocked (FLUSHALL, FLUSHDB, CONFIG, SHUTDOWN, EVAL, CLUSTER, ACL, CLIENT, REPLICAOF, …); ordinary commands (GET, TTL, TYPE, DBSIZE, INFO, SCAN, LLEN, HGETALL, …) are allowed. Credentials are never exposed; the database must be deployed. For SQL engines use neo_db_query.',
+    mutating: true,
+    schema: {
+      type: 'object',
+      properties: {
+        databaseId: str('Database id (redis, deployed)'),
+        command: str('Redis command, e.g. "GET mykey" or "INFO memory"'),
+        ...allowCrossEnvProp,
+      },
+      required: ['databaseId', 'command'],
+    },
+    async call(api, args) {
+      await assertResourceEnv(api, `/api/v1/databases/${args.databaseId}`, args.allowCrossEnvironment); // JNG #136 §4
+      return (await api.post(`/api/v1/databases/${args.databaseId}/redis-command`, { command: args.command })).data;
+    },
+  },
   {
     name: 'neo_set_variable',
     description:
@@ -812,7 +858,7 @@ export const TOOLS = [
       required: ['projectId', 'key', 'value'],
     },
     async call(api, args) {
-      const env = requireEnv(args.environment, args.allowCrossEnvironment);
+      const env = requireEnv(api, args.environment, args.allowCrossEnvironment);
       const path = `/api/v1/projects/${args.projectId}/environments/${env}/config`;
       // The PUT replaces the whole set, so merge current vars first.
       const current = (await api.get(path)).data?.vars || [];
@@ -864,15 +910,16 @@ export const TOOLS = [
     },
     async call(api, args) {
       if (args.confirm !== true) {
-        let computeTier;
+        let computeTier, currentReplicas;
         try {
           const apps = (await api.get(`/api/v1/projects/${args.projectId}/apps`)).data;
           const list = Array.isArray(apps) ? apps : (apps.applications || []);
           const svc = list.find((a) => a.name === args.service || a.id === args.service);
-          computeTier = svc && (svc.cpuLimit || svc.computeTier);
+          if (svc) { computeTier = svc.cpuLimit || svc.computeTier; currentReplicas = svc.replicas ?? svc.scaleMin; }
         } catch { /* best effort — gate regardless */ }
-        const gate = await confirmCost(api, args, { computeTier, replicas: args.replicas });
-        if (gate) return { ...gate, change: `scale "${args.service}" to ${args.replicas} replica(s)`, message: 'Scaling changes cost — show the user and re-call with confirm:true to apply.' };
+        // Price the delta against the current replica count so the user sees current → proposed → increase.
+        const gate = await confirmCost(api, args, { computeTier, replicas: args.replicas }, { computeTier, replicas: currentReplicas });
+        if (gate) return { ...gate, change: `scale "${args.service}" to ${args.replicas} replica(s)`, message: 'Scaling changes cost — show the user BOTH time bases and the increase, then re-call with confirm:true to apply.' };
       }
       const { status, data } = await api.post(
         `/api/v1/projects/${args.projectId}/services/${args.service}/scale`,
@@ -1010,7 +1057,7 @@ export const TOOLS = [
   },
   {
     name: 'neo_list_templates',
-    description: 'List deployable templates (e.g. wordpress, n8n, redis).',
+    description: 'List deployable templates (e.g. n8n) with their manifest: the Creates/Reuses resource graph, pinned source/version, min resources, public routes, and limitations — enough to show the resource graph and a live estimate before deploy. WordPress was retired.',
     mutating: false,
     schema: { type: 'object', properties: {} },
     async call(api) {
@@ -1019,7 +1066,7 @@ export const TOOLS = [
   },
   {
     name: 'neo_deploy_template',
-    description: 'Deploy a template (e.g. wordpress, n8n) into a project. May return pending_approval.',
+    description: 'Deploy a template (e.g. n8n) into a project. May return pending_approval. Retired templates (e.g. wordpress) return 410 "no longer available".',
     mutating: true,
     schema: {
       type: 'object',
@@ -1056,7 +1103,7 @@ export const TOOLS = [
       required: ['projectId', 'path', 'environment'],
     },
     async call(api, args) {
-      const environment = requireEnv(args.environment, args.allowCrossEnvironment);
+      const environment = requireEnv(api, args.environment, args.allowCrossEnvironment);
       const p = resolve(args.path);
       let src;
       try {
@@ -1116,7 +1163,7 @@ export const TOOLS = [
       properties: {
         projectId: str('Project id'),
         name: str('Database name'),
-        engine: { type: 'string', description: 'postgres | mysql (engine)' },
+        engine: { type: 'string', description: 'postgres | mysql | redis (also mariadb, mongo) — engine' },
         version: str('Engine version, e.g. "16" (optional)'),
         environment: { type: 'string', enum: ['staging', 'production'], description: 'REQUIRED — staging or production (never defaulted, handoff §2)' },
         ...allowCrossEnvProp,
@@ -1129,7 +1176,7 @@ export const TOOLS = [
       required: ['projectId', 'name', 'engine', 'environment'],
     },
     async call(api, args) {
-      const environment = requireEnv(args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
+      const environment = requireEnv(api, args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
       validateDbArgs(args); // reject sub-10Gi / EOL config before pricing (JNG #132)
       const gate = await billableGate(api, { projectId: args.projectId, kind: 'database', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm, environment }, { storageGB: gbFromSize(args.volumeSize), replicas: args.replicas });
       if (gate.requiresConfirmation) return { environment, ...gate };
@@ -1184,8 +1231,12 @@ export const TOOLS = [
     async call(api, args) {
       const costChanging = args.volumeSize || args.replicas !== undefined;
       if (costChanging && args.confirm !== true) {
-        const gate = await confirmCost(api, args, { storageGB: gbFromSize(args.volumeSize), replicas: args.replicas });
-        if (gate) return { ...gate, change: 'resize database (storage/replicas)', message: 'Resizing changes cost — re-call with confirm:true to apply.' };
+        // Read current storage for the change delta (current → proposed → increase).
+        let cur = {};
+        try { const d = (await api.get(`/api/v1/databases/${args.databaseId}`)).data; cur = (d && d.database) || d || {}; } catch { /* best-effort */ }
+        const currentSpec = { storageGB: cur.volumeSize ? gbFromSize(cur.volumeSize) : undefined, replicas: cur.replicas };
+        const gate = await confirmCost(api, args, { storageGB: gbFromSize(args.volumeSize), replicas: args.replicas }, currentSpec);
+        if (gate) return { ...gate, change: 'resize database (storage/replicas)', message: 'Resizing changes cost — show BOTH time bases and the increase, then re-call with confirm:true to apply.' };
       }
       const body = {};
       if (args.volumeSize) body.volumeSize = args.volumeSize;
@@ -1196,9 +1247,9 @@ export const TOOLS = [
   },
   {
     name: 'neo_verify_database',
-    description: 'Functionally verify a managed database (handoff §8.1): runs an in-cluster probe that opens the DB and does a SQL round-trip (SELECT 1), returning {verified, log} — WITHOUT handing you any credentials. Postgres only for now. Synchronous (waits up to ~60s for the probe).',
+    description: 'Functionally verify a managed database (handoff §8.1, #149): runs an in-cluster probe that connects and does an engine-level round trip — postgres/mysql a disposable SQL transaction, redis a namespaced SET/GET/TTL/DEL — returning {verified, check, log} WITHOUT handing you any credentials. This is the authoritative readiness check after neo_deploy_database. Synchronous (waits up to ~60s for the probe).',
     mutating: true,
-    schema: { type: 'object', properties: { databaseId: str('Database id (postgres)') }, required: ['databaseId'] },
+    schema: { type: 'object', properties: { databaseId: str('Database id (deployed)') }, required: ['databaseId'] },
     async call(api, args) {
       const { status, data } = await api.post(`/api/v1/databases/${args.databaseId}/verify`);
       return result(status, data);
@@ -1206,13 +1257,13 @@ export const TOOLS = [
   },
   {
     name: 'neo_restore_database',
-    description: 'Restore a postgres database from a prior backup (handoff 4.4). DESTRUCTIVE — applies the backup dump into the LIVE database (overwrites/merges) and is irreversible, so it requires confirm:true. Pass backupId for a specific backup, else the latest successful one is used. Local-destination backups only for now.',
+    description: 'Restore a postgres or mysql/mariadb database from a prior backup (handoff 4.4, #149). DESTRUCTIVE — applies the backup SQL dump into the LIVE database (overwrites/merges) and is irreversible, so it requires confirm:true. Pass backupId for a specific backup, else the latest successful one is used. Local-destination backups only for now. Redis RDB snapshots restore by a pod-level file swap, not here.',
     mutating: true,
     destructive: true,
     schema: {
       type: 'object',
       properties: {
-        databaseId: str('Database id (postgres)'),
+        databaseId: str('Database id (postgres/mysql)'),
         backupId: str('Backup id to restore from (optional; default the latest successful backup)'),
         confirm: { type: 'boolean', description: 'Must be true — restore overwrites data in the live database.' },
       },
@@ -1303,8 +1354,8 @@ export const TOOLS = [
       required: ['projectId', 'name', 'environment'],
     },
     async call(api, args) {
-      const environment = requireEnv(args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
-      const gate = await billableGate(api, { projectId: args.projectId, kind: 'queue', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm, environment }, { storageGB: gbFromSize(args.volumeSize) });
+      const environment = requireEnv(api, args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
+      const gate = await billableGate(api, { projectId: args.projectId, kind: 'queue', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm, environment }, { queue: true }); // queue bills per-message only (JNG #52) — 0 fixed + queue_message rate
       if (gate.requiresConfirmation) return { environment, ...gate };
       const { projectId, confirm, confirmationId, orgId, ...body } = args;
       body.environment = environment; // send the resolved env so the pin actually targets it
@@ -1359,8 +1410,10 @@ export const TOOLS = [
     async call(api, args) {
       const costChanging = args.volumeSize || args.planClass;
       if (costChanging && args.confirm !== true) {
-        const gate = await confirmCost(api, args, { storageGB: gbFromSize(args.volumeSize) });
-        if (gate) return { ...gate, change: 'update queue (storage/plan)', message: 'This changes cost — re-call with confirm:true to apply.' };
+        // A queue has no fixed cost — it bills per message (queue_message, JNG #52), so a
+        // storage/plan change doesn't move the fixed bill. The gate surfaces the per-message rate.
+        const gate = await confirmCost(api, args, { queue: true });
+        if (gate) return { ...gate, change: 'update queue (storage/plan)', message: 'Queue bills per message — no fixed-cost change; the queue_message rate is shown. Re-call with confirm:true to apply.' };
       }
       const { queueId, confirm, orgId, ...body } = args;
       const { status, data } = await api.put(`/api/v1/queues/${queueId}`, body);
@@ -1443,8 +1496,8 @@ export const TOOLS = [
       required: ['projectId', 'name', 'mode', 'scheduleType', 'environment'],
     },
     async call(api, args) {
-      const environment = requireEnv(args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
-      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
+      const environment = requireEnv(api, args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
+      const gate = await billableGate(api, { projectId: args.projectId, kind: 'cron', name: args.name, confirmationId: args.confirmationId, confirm: args.confirm }, { cron: true }); // cron has no fixed cost — the contract surfaces the per-run `cron_run` rate in cost.variable
       if (gate.requiresConfirmation) return { environment, ...gate };
       // Merge contentType into headers for convenience (unless already set).
       if (args.contentType) {
@@ -1618,8 +1671,9 @@ export const TOOLS = [
       if (!allowCrossEnvironment) {
         let cEnv;
         try { cEnv = (await api.get(`/api/v1/apps/${appId}`)).data?.environment; } catch { /* can't resolve → don't block */ }
-        if (sessionEnv && cEnv && cEnv !== sessionEnv) {
-          throw new Error(`environment_mismatch: this session is pinned to "${sessionEnv}" but that service is in "${cEnv}" (JNG #136). Pass allowCrossEnvironment:true to override, or re-pin with neo_set_context.`);
+        const pinnedEnv = getSessionEnv(api);
+        if (pinnedEnv && cEnv && cEnv !== pinnedEnv) {
+          throw new Error(`environment_mismatch: this session is pinned to "${pinnedEnv}" but that service is in "${cEnv}" (JNG #136). Pass allowCrossEnvironment:true to override, or re-pin with neo_set_context.`);
         }
         if (args.targetType !== 'neo_object_storage') {
           const tPath = args.targetType === 'neo_db' ? `/api/v1/databases/${args.targetId}` : `/api/v1/queues/${args.targetId}`;
@@ -1771,7 +1825,7 @@ export const TOOLS = [
       required: ['projectId', 'environment', 'resources'],
     },
     async call(api, args) {
-      const environment = requireEnv(args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
+      const environment = requireEnv(api, args.environment, args.allowCrossEnvironment); // explicit, else the session pin (JNG #136)
       const { projectId, ...body } = args;
       body.environment = environment; // send the resolved env so the pin actually targets it
       const { status, data } = await api.post(`/api/v1/projects/${projectId}/plans`, body);
@@ -2027,7 +2081,11 @@ export const TOOLS = [
     },
     async call(api, args) {
       const { status, data } = await api.post(`/api/v1/databases/${args.databaseId}/public-access`, { allowlistCidrs: args.allowlistCidrs || [] });
-      return redactSecrets(result(status, data));
+      const out = redactSecrets(result(status, data));
+      // Public access adds no fixed monthly charge, but egress through the gateway is metered
+      // per GB (usage-based). Surface that so enabling it isn't a silent billing change (#170).
+      if (out && typeof out === 'object') out.billingNote = 'No fixed monthly cost is added. Data transfer (egress) through the public TLS gateway is metered per GB — see the usage-based rates via neo_estimate (cost.variable).';
+      return out;
     },
   },
   {
@@ -2054,7 +2112,9 @@ export const TOOLS = [
     },
     async call(api, args) {
       const { status, data } = await api.post(`/api/v1/queues/${args.queueId}/public-access`, { allowlistCidrs: args.allowlistCidrs || [] });
-      return redactSecrets(result(status, data));
+      const out = redactSecrets(result(status, data));
+      if (out && typeof out === 'object') out.billingNote = 'No fixed monthly cost is added. Data transfer (egress) through the public TLS gateway is metered per GB — see the usage-based rates via neo_estimate (cost.variable).';
+      return out;
     },
   },
   {