@biznetgio/neo-app 0.4.29 → 0.4.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biznetgio/neo-app",
-  "version": "0.4.29",
+  "version": "0.4.31",
   "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

@@ -2,11 +2,11 @@
 NEO App setup prompt — served at https://portal.neoapp.biznetgio.dev/prompt.md (staging)
 and https://portal.app.neoapp.id/prompt.md (production).
 Contains NO credentials or user-specific secrets. Versioned; keep last-updated current.
-Keep this in sync with pkg/api/prompt.md (the copy the Go server embeds).
+Keep this in sync with cli/prompt.md (the npm package's bundled copy).
 -->
 # Set this repo up on NEO App
 
-**Version:** 0.4.3 · **Last updated:** 2026-10-13
+**Version:** 0.4.4 · **Last updated:** 2026-10-15
 
 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
@@ -109,6 +109,35 @@ tool. Report the connected account, organization, environment, detected agent
 integrations, and any unresolved errors. **Do not deploy unless the human separately
 asked for a deployment.**
 
+## Deploying a resource (the MCP lifecycle)
+
+Once setup is verified and the human has asked for a deployment, use the `neo_*` MCP
+tools — never the portal UI. The lifecycle is the same for every resource type:
+
+1. **Understand the repo** (for code deploys): `neo_scan_repo` enumerates deployable
+   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
+   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`.
+3. **Apply**: `neo_apply_stack({planId, planHash})`. If the price book changed since the
+   plan, apply is refused — re-plan to re-quote. A `pending_approval` result is the
+   approval policy working, not an error; wait for it.
+4. **Watch it reach health**: `neo_wait_operation` until terminal — the plan deploys in
+   dependency order and gates on health.
+5. **Prove it works**: `neo_verify_database` (SQL round-trip), read logs, hit the URL.
+6. **Clean up** when asked: `neo_delete_*` / `neo_delete_stack`, or `neo_delete_project`
+   (confirm-guarded) for the whole project.
+
+For a **scheduled job**, call `neo_cron_questionnaire` first to collect the schedule and
+target, then `neo_create_cron`. To expose a managed database or queue to the internet,
+use `neo_enable_db_public_access` / `neo_enable_queue_public_access` (deploy it first).
+
+Never deploy to **production** without an explicit request, and never default a missing
+environment — every create/deploy names `staging` or `production`.
+
 ## Environment
 
 The CLI targets production by default. Set `NEO_APP_URL` to point it at a different

package/src/deploySource.js

@@ -273,7 +273,8 @@ export async function deploySource(api, { projectId, src, name, port, build, ser
     try {
       const book = (await api.get('/api/v1/pricing')).data;
       estimatedCost = estimateCost(book, { computeTier: 'micro' });
-      log(`[dry-run] estimated cost (default micro compute, ${svcType}): ~${estimatedCost.monthly} ${estimatedCost.currency}/mo (${estimatedCost.hourly}/h) — ${estimatedCost.assumptions}. Use neo_estimate for a specific size.`);
+      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 };
   }

package/src/mcp/tools.js

@@ -120,10 +120,10 @@ export const TOOLS = [
         { type: 'template', create: true, deploy: true, scale: false, logs: true, variables: true, delete: true },
         { type: 'static_site', create: 'via_folder', deploy: true, scale: false, logs: true, variables: true, delete: true, nativeStatic: true, note: 'neo_deploy_folder serviceType=static_site with buildCommand/publishDirectory → native nginx static hosting (0.4.27); auto-detected for static-only folders' },
         { type: 'worker', create: 'via_folder', deploy: true, scale: true, logs: true, variables: true, delete: true, note: 'neo_deploy_folder serviceType=worker — no public ingress; repo auto-detection still TODO (handoff 6)' },
-        { type: 'database', create: true, get: true, list: true, update: true, backup: true, verify: true, publicAccess: true, delete: true, note: 'neo_create/list/get/update(resize)/delete_database + backup + verify (SQL round-trip probe) + enable/disable_db_public_access; restore still TODO (handoff 4.4)' },
-        { type: 'queue', create: true, get: true, list: true, update: true, publicAccess: true, delete: true, note: 'neo_create/list/get/update/delete_queue + enable/disable_queue_public_access (handoff 4.5)' },
-        { type: 'cron', create: true, get: true, list: true, run: true, runs: true, delete: true, note: 'neo_create/list/get/run/list_runs/delete_cron (0.4.15-0.4.21) (handoff 4.6)' },
-        { type: 'object_storage', create: true, get: true, list: true, objects: true, upload: true, delete: true, note: 'neo_create/list/get/delete_bucket + list/upload/presign(get)/delete objects (0.4.15-0.4.25) (handoff 4.7)' },
+        { type: 'database', create: true, deploy: true, get: true, list: true, update: true, backup: true, verify: true, publicAccess: true, delete: true, note: 'neo_create/deploy/list/get/update(resize)/delete_database + backup + verify (SQL round-trip probe) + enable/disable_db_public_access; restore still TODO (handoff 4.4)' },
+        { 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)' },
       ];
 
       return {
@@ -131,8 +131,8 @@ export const TOOLS = [
         controlPlane,
         resourceTypes,
         // Verbs this MCP build exposes today (no create-DB/queue/cron/bucket, no costed plan/apply yet).
-        lifecycleVerbs: ['plan', 'apply', 'get_operation', 'wait_operation', 'delete_stack', 'reconcile_usage', 'service_usage', 'create', 'list', 'get', 'update', 'verify', 'enable_public_access', 'disable_public_access', 'deploy', 'scale', 'logs', 'get_variables', 'set_variable', 'estimate', 'scan_repo', 'bind', 'unbind', 'run_cron', 'presign_object', 'backup', 'delete', 'delete_project', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
-        bindings: { supported: true, targets: ['neo_db', 'neo_queue'], writeOnly: true, note: 'neo_bind_resource injects DATABASE_URL/NATS_URL server-side at deploy; the secret is never returned (handoff 5)' },
+        lifecycleVerbs: ['plan', 'apply', 'get_operation', 'wait_operation', 'delete_stack', 'reconcile_usage', 'service_usage', 'create', 'list', 'get', 'update', 'verify', 'enable_public_access', 'disable_public_access', 'deploy', 'scale', 'logs', 'get_variables', 'set_variable', 'estimate', 'scan_repo', 'bind', 'unbind', 'run_cron', 'cron_questionnaire', 'presign_object', 'backup', 'delete', 'delete_project', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
+        bindings: { supported: true, targets: ['neo_db', 'neo_queue', 'neo_object_storage'], writeOnly: true, note: 'neo_bind_resource + neo_plan_stack bindings inject DATABASE_URL / NATS_URL (+ NATS_HOST/PORT/USER/PASSWORD) / S3_* server-side at deploy; secrets never returned (handoff 5)' },
         sourceTypes: ['git', 'image', 'dockerfile', 'local', 'template'],
         environments: ['staging', 'production'],
         pricing,
@@ -386,32 +386,44 @@ export const TOOLS = [
     async call(api, args) {
       const { data } = await api.post('/api/v1/repos/scan', { repoUrl: args.repoUrl, branch: args.branch, gitProviderId: args.gitProviderId });
       const subdirs = data?.subdirs || [];
-      const components = subdirs.map((s) => ({
-        path: s.path || '.',
-        name: s.name,
-        stack: s.type, // docker | node | go | python | java | php | ruby | rust | static
-        suggestedServiceType: s.type === 'static' ? 'static_site' : 'web',
-        suggestedBuildType: s.type === 'docker' ? 'dockerfile' : 'railpack',
-        contextDir: s.path || undefined,
-        detectedDependencies: s.deps || [], // database | queue | object_storage, inferred from the manifest
-        // Confidence + evidence (handoff 6): an explicit Dockerfile/index.html is high
-        // confidence; a language marker is inferred (medium). The stack marker + any
-        // detectedDependencies ARE the evidence.
-        typeConfidence: (s.type === 'docker' || s.type === 'static') ? 'high' : 'medium',
-        evidence: { marker: s.type, manifestDeps: s.deps || [] },
-      }));
+      const components = subdirs.map((s) => {
+        const role = s.role || 'service'; // service | worker | support
+        const support = role === 'support' || s.deployable === false;
+        return {
+          path: s.path || '.',
+          name: s.name,
+          stack: s.type, // docker | node | go | python | java | php | ruby | rust | static
+          role, // service | worker | support (library/config — not deployable)
+          deployable: !support,
+          // Don't suggest a service type for a support/library package; a worker-named
+          // root suggests worker; static → static_site; else web.
+          suggestedServiceType: support ? null : (role === 'worker' ? 'worker' : (s.type === 'static' ? 'static_site' : 'web')),
+          suggestedBuildType: s.type === 'docker' ? 'dockerfile' : 'railpack',
+          contextDir: s.path || undefined,
+          detectedDependencies: s.deps || [], // database | queue | object_storage, inferred from the manifest
+          // Confidence (handoff 6): a Dockerfile/index.html is high; a worker guess from
+          // the tree is low (confirm); a plain language marker is medium.
+          typeConfidence: support ? 'low' : (role === 'worker' ? 'low' : ((s.type === 'docker' || s.type === 'static') ? 'high' : 'medium')),
+          evidence: { marker: s.type, role, manifestDeps: s.deps || [] },
+        };
+      });
+      const deployable = components.filter((c) => c.deployable);
+      const support = components.filter((c) => !c.deployable);
       const anyDeps = components.some((c) => c.detectedDependencies.length);
       return {
         repoUrl: args.repoUrl,
         count: components.length,
+        deployableCount: deployable.length,
         components,
         note:
-          (components.length > 1
-            ? 'Monorepo: multiple deployable components. Ask the user which to deploy and create each selected one with its `contextDir` — do NOT collapse them into one service (handoff 6). Worker vs web cannot be inferred from the tree alone; confirm the type with the user.'
-            : components.length === 1
+          (deployable.length > 1
+            ? 'Monorepo: multiple deployable components. Ask the user which to deploy and create each selected one with its `contextDir` — do NOT collapse them into one service (handoff 6).'
+            : deployable.length === 1
               ? 'One deployable component found.'
-              : 'No deployable component found (no Dockerfile/package.json/go.mod/requirements.txt/index.html/… at any root).')
-          + (anyDeps ? ' A component lists detectedDependencies (database/queue/object_storage) from its manifest — consider planning those resources and binding them (neo_bind_resource); confirm with the user first.' : ''),
+              : 'No deployable component found.')
+          + (support.length ? ` ${support.length} support/library package(s) (role:support, deployable:false) were EXCLUDED from deployment — do not deploy config/lib packages (e.g. eslint/tsconfig/shared).` : '')
+          + (components.some((c) => c.role === 'worker') ? ' A component is guessed as a worker (low confidence) — confirm web vs worker with the user.' : ' Worker vs web is a guess; confirm the type with the user.')
+          + (anyDeps ? ' Some components list detectedDependencies (database/queue/object_storage) — consider planning + binding them (confirm first).' : ''),
       };
     },
   },
@@ -535,6 +547,16 @@ export const TOOLS = [
       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.',
+    mutating: true,
+    schema: { type: 'object', properties: { databaseId: str('Database id (from neo_create_database)') }, required: ['databaseId'] },
+    async call(api, args) {
+      const { status, data } = await api.post(`/api/v1/databases/${args.databaseId}/deploy`);
+      return redactSecrets(result(status, data));
+    },
+  },
   {
     name: 'neo_list_databases',
     description: 'List managed databases in a project (credentials redacted).',
@@ -584,6 +606,26 @@ export const TOOLS = [
       return result(status, data);
     },
   },
+  {
+    name: 'neo_verify_queue',
+    description: 'Functionally verify a managed queue (handoff §8): runs an in-cluster probe that connects to NATS JetStream, publishes a message to a temporary stream, and confirms it was persisted — a real publish→persist round-trip, returning {verified, log} WITHOUT handing you any credentials. The queue must be deployed. Synchronous (~90s).',
+    mutating: true,
+    schema: { type: 'object', properties: { queueId: str('Queue id (deployed)') }, required: ['queueId'] },
+    async call(api, args) {
+      const { status, data } = await api.post(`/api/v1/queues/${args.queueId}/verify`);
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_verify_bucket',
+    description: 'Functionally verify an object-storage bucket (handoff §8/§9): does a put → list → delete round-trip of a tiny temporary object through the real OBS backend, proving the bucket credentials and endpoint work, returning {verified, put, listed, deleted}. The probe object is always cleaned up. No credentials returned.',
+    mutating: true,
+    schema: { type: 'object', properties: { bucketId: str('Bucket id') }, required: ['bucketId'] },
+    async call(api, args) {
+      const { status, data } = await api.post(`/api/v1/buckets/${args.bucketId}/verify`);
+      return result(status, data);
+    },
+  },
   {
     name: 'neo_list_backups',
     description: 'List configured database backups in a project (handoff 4.4): schedule, destination, last run status.',
@@ -649,6 +691,16 @@ export const TOOLS = [
       return redactSecrets(result(status, data));
     },
   },
+  {
+    name: 'neo_deploy_queue',
+    description: 'Deploy an individually-created managed queue so it actually runs (provisions the NATS server, sets its private host/port). Required after neo_create_queue before the queue is reachable, bindable, or can have public access enabled. Poll neo_get_queue until host is set and neo_verify_queue passes. Credentials redacted.',
+    mutating: true,
+    schema: { type: 'object', properties: { queueId: str('Queue id (from neo_create_queue)') }, required: ['queueId'] },
+    async call(api, args) {
+      const { status, data } = await api.post(`/api/v1/queues/${args.queueId}/deploy`);
+      return redactSecrets(result(status, data));
+    },
+  },
   {
     name: 'neo_list_queues',
     description: 'List managed queues in a project (credentials redacted).',
@@ -688,9 +740,43 @@ export const TOOLS = [
       return redactSecrets(result(status, data));
     },
   },
+  {
+    name: 'neo_cron_questionnaire',
+    description: 'Return the ordered questions (with allowed values and which neo_create_cron field each answer fills) needed to define a scheduled job. Read-only — call this FIRST when a user wants a cron but has not given a full schedule/target, ask them these questions, then call neo_create_cron with the collected answers (handoff 4.6).',
+    mutating: false,
+    schema: { type: 'object', properties: {} },
+    async call() {
+      return {
+        questions: [
+          { field: 'name', ask: 'What should this job be called?', type: 'string' },
+          { field: 'mode', ask: 'What does the job run?', type: 'enum', options: [
+            { value: 'app_command', when: 'run a command inside an existing service, or a one-off image', fills: ['serviceId OR image', 'command'] },
+            { value: 'http_endpoint', when: 'call a URL on a schedule (webhook/ping)', fills: ['url', 'method'] },
+          ] },
+          { field: 'scheduleType', ask: 'How often should it run?', type: 'enum', options: [
+            { value: 'cron', fills: ['schedule'], hint: 'cron expression, e.g. "0 * * * *" (hourly)' },
+            { value: 'interval', fills: ['intervalMinutes'], hint: 'every N minutes' },
+            { value: 'seconds', fills: ['intervalMinutes'], hint: 'sub-minute/seconds cadence' },
+            { value: 'once', fills: [], hint: 'run a single time' },
+          ] },
+          { field: 'timezone', ask: 'Which timezone for the schedule? (optional, IANA, e.g. Asia/Jakarta)', type: 'string', optional: true },
+          { field: 'environment', ask: 'staging or production? (never defaulted)', type: 'enum', options: ['staging', 'production'], required: true },
+        ],
+        branches: {
+          app_command: 'Provide serviceId (an existing service) OR image, plus command (argv array).',
+          http_endpoint: 'Provide url and method (GET/POST/…).',
+        },
+        examples: [
+          { intent: 'Run `node cleanup.js` in my web service every night at 2am Jakarta', args: { name: 'nightly-cleanup', mode: 'app_command', scheduleType: 'cron', schedule: '0 2 * * *', timezone: 'Asia/Jakarta', serviceId: '<web service id>', command: ['node', 'cleanup.js'], environment: 'staging' } },
+          { intent: 'Ping a health URL every 15 minutes', args: { name: 'healthcheck', mode: 'http_endpoint', scheduleType: 'interval', intervalMinutes: 15, url: 'https://example.app/health', method: 'GET', environment: 'production' } },
+        ],
+        next: 'Collect the answers, then call neo_create_cron. It may return pending_approval (expected).',
+      };
+    },
+  },
   {
     name: 'neo_create_cron',
-    description: 'Create a scheduled job (cron) in a project (handoff 4.6). Target is either an existing service command (mode=app_command, serviceId+command) or an HTTP endpoint (mode=http_endpoint, url+method). Schedule via scheduleType (cron|interval|once|seconds) + schedule/intervalMinutes. May return pending_approval.',
+    description: 'Create a scheduled job (cron) in a project (handoff 4.6). If the user gave an incomplete spec, call neo_cron_questionnaire first. Target is either an existing service command (mode=app_command, serviceId+command) or an HTTP endpoint (mode=http_endpoint, url+method). Schedule via scheduleType (cron|interval|once|seconds) + schedule/intervalMinutes. May return pending_approval.',
     mutating: true,
     schema: {
       type: 'object',
@@ -708,12 +794,15 @@ export const TOOLS = [
         url: str('Target URL (mode=http_endpoint)'),
         method: str('HTTP method (mode=http_endpoint), e.g. GET/POST'),
         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.' },
       },
       required: ['projectId', 'name', 'mode', 'scheduleType', 'environment'],
     },
     async call(api, args) {
       requireEnv(args.environment);
-      const { projectId, ...body } = args;
+      const gate = await confirmCost(api, args, {}); // cron cost is variable (per-run) — gate surfaces the rate
+      if (gate) return gate;
+      const { projectId, confirm, orgId, ...body } = args;
       const { status, data } = await api.post(`/api/v1/projects/${projectId}/crons`, body);
       return redactSecrets(result(status, data));
     },
@@ -767,11 +856,14 @@ 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.' },
       },
       required: ['projectId', 'name'],
     },
     async call(api, args) {
-      const { projectId, ...body } = 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);
       return redactSecrets(result(status, data));
     },
@@ -898,7 +990,7 @@ export const TOOLS = [
   {
     name: 'neo_plan_stack',
     description:
-      'Create an immutable, COSTED plan for a whole stack (services + databases/queues/buckets + bindings) WITHOUT creating anything — zero-write (handoff 3.3). Returns planId, planHash, itemized monthly/hourly cost, and ordered phases. Show the cost to the user for approval, then call neo_apply_stack with planId+planHash. The plan expires in 15 minutes.',
+      'Create an immutable, COSTED plan for a whole stack (services + databases/queues/buckets + scheduled jobs + bindings) WITHOUT creating anything — zero-write (handoff 3.3). Supports kind: app|database|queue|bucket|cron and bindings to neo_db|neo_queue|neo_object_storage. Returns planId, planHash, itemized monthly/hourly cost, and ordered phases. Show the cost to the user for approval, then call neo_apply_stack with planId+planHash. The plan expires in 15 minutes.',
     mutating: false,
     schema: {
       type: 'object',
@@ -907,16 +999,16 @@ export const TOOLS = [
         environment: { type: 'string', enum: ['staging', 'production'], description: 'REQUIRED — staging or production (never defaulted, handoff §2)' },
         resources: {
           type: 'array',
-          description: 'The stack resources. Each needs a unique name + kind (app | database | queue | bucket).',
+          description: 'The stack resources. Each needs a unique name + kind (app | database | queue | bucket | cron).',
           items: {
             type: 'object',
             properties: {
-              kind: { type: 'string', enum: ['app', 'database', 'queue', 'bucket'] },
+              kind: { type: 'string', enum: ['app', 'database', 'queue', 'bucket', 'cron'] },
               name: str('Unique resource name within this stack (bindings reference it)'),
               serviceType: str('app: web | worker | static_site'),
               buildCommand: str('app/static_site: build command (e.g. "npm ci && npm run build")'),
               publishDirectory: str('static_site: built-files directory to serve (e.g. "dist")'),
-              image: str('app: prebuilt image reference'),
+              image: str('app/cron: prebuilt image reference'),
               repoUrl: str('app: git repository URL'),
               branch: str('app: git branch'),
               port: int('app: container port'),
@@ -926,20 +1018,29 @@ export const TOOLS = [
               volumeSize: str('database: storage size, e.g. 10Gi'),
               quotaGB: int('bucket: storage quota GB'),
               region: str('bucket: region'),
+              mode: str('cron: app_command | http_endpoint'),
+              scheduleType: str('cron: cron | interval | once | seconds'),
+              schedule: str('cron: cron expression (scheduleType=cron)'),
+              intervalMinutes: int('cron: interval in minutes (scheduleType=interval)'),
+              timezone: str('cron: IANA timezone (optional)'),
+              serviceId: str('cron app_command: target service — another resource NAME in this stack, or a literal service id'),
+              command: { type: 'array', items: { type: 'string' }, description: 'cron app_command: command argv' },
+              url: str('cron http_endpoint: target URL'),
+              method: str('cron http_endpoint: HTTP method'),
             },
             required: ['kind', 'name'],
           },
         },
         bindings: {
           type: 'array',
-          description: 'Wire a database/queue into a consumer app (injected as an env var at deploy, server-side).',
+          description: 'Wire a database/queue/bucket into a consumer app (injected as env var(s) at deploy, server-side).',
           items: {
             type: 'object',
             properties: {
               consumer: str('The consumer app resource name'),
-              targetType: { type: 'string', enum: ['neo_db', 'neo_queue'] },
-              target: str('The database/queue resource name'),
-              envKey: str('Env var name (optional; default DATABASE_URL / NATS_URL)'),
+              targetType: { type: 'string', enum: ['neo_db', 'neo_queue', 'neo_object_storage'] },
+              target: str('The database/queue/bucket resource name'),
+              envKey: str('Env var name/prefix (optional; default DATABASE_URL / NATS_URL / S3)'),
             },
             required: ['consumer', 'targetType', 'target'],
           },
@@ -1125,9 +1226,9 @@ export const TOOLS = [
       type: 'object',
       properties: {
         databaseId: str('Database id (postgres, already deployed)'),
-        allowlistCidrs: { type: 'array', items: { type: 'string' }, description: 'CIDR allowlist, e.g. ["203.0.113.0/24"] (optional; empty = allow any source IP)' },
+        allowlistCidrs: { type: 'array', items: { type: 'string' }, description: 'REQUIRED — at least one real source CIDR, e.g. ["203.0.113.0/24"]. The server rejects an empty list and 0.0.0.0/0 (no open-to-the-world).' },
       },
-      required: ['databaseId'],
+      required: ['databaseId', 'allowlistCidrs'],
     },
     async call(api, args) {
       const { status, data } = await api.post(`/api/v1/databases/${args.databaseId}/public-access`, { allowlistCidrs: args.allowlistCidrs || [] });
@@ -1152,9 +1253,9 @@ export const TOOLS = [
       type: 'object',
       properties: {
         queueId: str('Queue id (already deployed)'),
-        allowlistCidrs: { type: 'array', items: { type: 'string' }, description: 'CIDR allowlist (optional; empty = allow any source IP)' },
+        allowlistCidrs: { type: 'array', items: { type: 'string' }, description: 'REQUIRED — at least one real source CIDR, e.g. ["203.0.113.0/24"]. The server rejects an empty list and 0.0.0.0/0.' },
       },
-      required: ['queueId'],
+      required: ['queueId', 'allowlistCidrs'],
     },
     async call(api, args) {
       const { status, data } = await api.post(`/api/v1/queues/${args.queueId}/public-access`, { allowlistCidrs: args.allowlistCidrs || [] });
@@ -1173,23 +1274,55 @@ export const TOOLS = [
   },
   {
     name: 'neo_delete_project',
-    description: 'Permanently delete a project and ALL its resources (apps, databases, queues, crons, buckets, and the project namespace with its PVCs/CNPG clusters). Destructive and irreversible — nothing is recoverable. Requires confirm:true. Only the project creator or an org owner/admin may delete it.',
+    description: 'Delete a project and ALL its resources (apps, databases, queues, crons, buckets, namespace + PVCs/CNPG). SAFE BY DEFAULT: without confirm:true it returns a PREVIEW (project name, org, full resource inventory, accrued-usage snapshot, no-refund warning) and deletes NOTHING. A NON-EMPTY project additionally requires cascade:true. Destructive and irreversible. Only the creator or an org owner/admin may delete.',
     mutating: true,
     destructive: true,
     schema: {
       type: 'object',
       properties: {
         projectId: str('Project id'),
-        confirm: { type: 'boolean', description: 'Must be true to proceed — guards against accidental deletion of an entire project.' },
+        confirm: { type: 'boolean', description: 'Must be true to delete. Without it you get a preview only (nothing is deleted).' },
+        cascade: { type: 'boolean', description: 'Required true to delete a NON-EMPTY project — acknowledges every resource in the inventory is destroyed.' },
       },
-      required: ['projectId', 'confirm'],
+      required: ['projectId'],
     },
     async call(api, args) {
+      const pid = args.projectId;
+      // Gather inventory + usage BEFORE any delete (this is also the metering snapshot).
+      const safeGet = async (p) => { try { return (await api.get(p)).data; } catch { return null; } };
+      const [proj, apps, dbs, queues, crons, buckets, usage] = await Promise.all([
+        safeGet(`/api/v1/projects/${pid}`),
+        safeGet(`/api/v1/projects/${pid}/apps`),
+        safeGet(`/api/v1/projects/${pid}/databases`),
+        safeGet(`/api/v1/projects/${pid}/queues`),
+        safeGet(`/api/v1/projects/${pid}/crons`),
+        safeGet(`/api/v1/projects/${pid}/buckets`),
+        safeGet(`/api/v1/projects/${pid}/usage`),
+      ]);
+      const arr = (x, k) => (Array.isArray(x) ? x : (x && Array.isArray(x[k]) ? x[k] : []));
+      const inv = {
+        services: arr(apps, 'apps').map((a) => a.name || a.id),
+        databases: arr(dbs, 'databases').map((d) => d.name || d.id),
+        queues: arr(queues, 'queues').map((q) => q.name || q.id),
+        crons: arr(crons, 'crons').map((c) => c.name || c.id),
+        buckets: arr(buckets, 'buckets').map((b) => b.name || b.id),
+      };
+      const total = Object.values(inv).reduce((n, a) => n + a.length, 0);
+      const preview = {
+        project: proj ? { id: proj.id, name: proj.name, organizationId: proj.organizationId } : { id: pid },
+        resourceInventory: inv,
+        resourceCount: total,
+        meteringSnapshot: usage ? { period: usage.period, total: usage.total ?? usage.totalCost, currency: usage.currency } : null,
+        warning: 'IRREVERSIBLE: deletes the project, every resource above, and their data (database/queue volumes included). No refund for prepaid or accrued usage.',
+      };
       if (args.confirm !== true) {
-        return { error: 'refused', message: 'Deleting a project removes ALL its resources and is irreversible. Re-call with confirm:true to proceed.' };
+        return { ...preview, deleted: false, requiresConfirmation: true, message: total > 0 ? 'Show this inventory to the user. To delete, re-call with confirm:true AND cascade:true.' : 'Empty project. To delete, re-call with confirm:true.' };
       }
-      const { status, data } = await api.del(`/api/v1/projects/${args.projectId}`);
-      return result(status, data);
+      if (total > 0 && args.cascade !== true) {
+        return { ...preview, deleted: false, error: 'cascade_required', message: `This project has ${total} resource(s). Re-call with confirm:true AND cascade:true to delete them all.` };
+      }
+      const { status, data } = await api.del(`/api/v1/projects/${pid}`);
+      return { deleted: true, project: preview.project, removed: inv, resourceCount: total, meteringSnapshot: preview.meteringSnapshot, result: result(status, data) };
     },
   },
 ];