@hoststack.dev/mcp 0.13.1 → 0.16.0

package/dist/index.js

@@ -2,6 +2,10 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { HostStack } from "@hoststack.dev/sdk";
 
+// src/version.ts
+var MCP_VERSION = true ? "0.16.0" : "0.0.0-dev";
+var USER_AGENT = `hoststack-mcp/${MCP_VERSION}`;
+
 // src/api-client.ts
 var ApiClient = class {
   constructor(apiKey, baseUrl) {
@@ -11,7 +15,8 @@ var ApiClient = class {
   get headers() {
     return {
       Authorization: `Bearer ${this.apiKey}`,
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
     };
   }
   async get(path, params) {
@@ -58,8 +63,8 @@ var ApiClient = class {
   }
   async handle(res) {
     if (!res.ok) {
-      const error = await res.json().catch(() => ({ error: res.statusText }));
-      throw new Error(error.error ?? `API error: ${res.status}`);
+      const body = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(formatApiError(body, res.status));
     }
     if (res.status === 204) {
       return void 0;
@@ -67,6 +72,31 @@ var ApiClient = class {
     return res.json();
   }
 };
+function formatApiError(body, status) {
+  const fallback = `API error: ${status}`;
+  if (!body || typeof body !== "object") return fallback;
+  const err = body.error;
+  if (typeof err === "string") return err.trim() ? err : fallback;
+  const issues = Array.isArray(err) ? err : err && typeof err === "object" && Array.isArray(err.issues) ? err.issues : null;
+  if (issues && issues.length > 0) {
+    const rendered = issues.map((issue) => {
+      if (!issue || typeof issue !== "object") return String(issue);
+      const { path, message } = issue;
+      const field = Array.isArray(path) && path.length > 0 ? path.join(".") : null;
+      const text = typeof message === "string" ? message : "invalid value";
+      return field ? `${field}: ${text}` : text;
+    }).join("; ");
+    return `Invalid request \u2014 ${rendered}`;
+  }
+  if (err !== void 0) {
+    try {
+      return `${fallback}: ${JSON.stringify(err)}`;
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
 
 // src/prompts/registry.ts
 var prompts = [];
@@ -592,11 +622,176 @@ defineTool({
 
 // src/tools/databases.ts
 import { z as z5 } from "zod";
+var DATABASE_VERSIONS = {
+  postgres: { default: "18", supported: ["18", "17", "16", "15"] },
+  redis: { default: "8", supported: ["8", "7", "6"] },
+  mysql: { default: "8.4", supported: ["8.4", "8.0", "5.7"] },
+  mariadb: { default: "11.4", supported: ["11.4", "10.11"] },
+  mongodb: { default: "8", supported: ["8", "7", "6"] }
+};
+var DB_ENGINES = ["postgres", "redis", "mysql", "mariadb", "mongodb"];
+var VERSION_HELP = Object.keys(DATABASE_VERSIONS).map(
+  (e) => `${e}: ${DATABASE_VERSIONS[e].supported.join("/")} (default ${DATABASE_VERSIONS[e].default})`
+).join("; ");
+defineTool({
+  name: "create_database",
+  category: "databases",
+  description: [
+    "Provision a MANAGED database (Postgres, Redis, MySQL, MariaDB, MongoDB) in a project. This is the correct and ONLY supported way to add a database to a HostStack app.",
+    "",
+    'When to use: any time an app needs a datastore \u2014 "add a database", "I need Postgres", "set up Redis", "give this service a DB". Also the right call when scaffolding a new app that will need persistence.',
+    "",
+    '*** Do NOT hand-roll a database as a service. *** Deploying `postgres:16` (or redis/mysql/mongo) via create_service with a docker_image is NOT how databases work on this platform: it gets no managed backups, no automated version upgrades, no HA/failover path, no credential rotation, no metrics, no persistent volume wired up, and nothing will inject its connection URL into your app. If the user says "add a database", "I need Postgres", "set up Redis" \u2014 call THIS tool.',
+    "",
+    "How a database reaches your app (the whole flow \u2014 3 calls, no secrets handled):",
+    "  1. create_database({ project_id, name, engine }) \u2014 provisions it.",
+    '  2. link_resource_to_service({ service_id, resource_type: "database", resource_id: <database.id>, alias: "APP_DB" }) \u2014 binds it to the service that needs it.',
+    "  3. trigger_deploy({ service_id }) \u2014 on that deploy the platform injects the connection info as env vars.",
+    "After step 3 the container has `DATABASE_URL` (postgres/mysql/mariadb), `REDIS_URL` (redis) or `MONGO_URL` (mongodb) set automatically, plus alias-prefixed vars. An app reading `process.env.DATABASE_URL` needs zero code changes. You never have to fetch, generate or paste a password.",
+    "",
+    "Inputs:",
+    '  - project_id: numeric id or publicId ("prj_\u2026") of the target project.',
+    "  - name: database name (1\u2013100 chars).",
+    `  - engine: ${DB_ENGINES.join(" | ")}.`,
+    `  - version (optional): engine version. Supported \u2014 ${VERSION_HELP}. Omit to get the default (recommended).`,
+    '  - plan (optional): "micro" | "starter" | "standard" | "pro" (default "starter"). "starter" is the smallest always-on tier that includes backups.',
+    "  - environment_id (optional): bind to a specific environment; defaults to the project Production env.",
+    "  - postgis (optional): provision the PostGIS image variant so `CREATE EXTENSION postgis` works. Postgres only.",
+    "  - pgvector (optional): provision the pgvector image variant so `CREATE EXTENSION vector` works. Postgres only, mutually exclusive with postgis.",
+    "",
+    'Returns: { database: Database } \u2014 note BOTH `id` (numeric \u2014 this is what link_resource_to_service wants) and `publicId` ("db_\u2026" \u2014 what the other database tools want).',
+    "",
+    'Provisioning is async: the row comes back immediately, usually as `creating`. Poll get_database until `status === "available"` before linking or connecting.',
+    "",
+    'Example: create_database({ project_id: "prj_abc", name: "app-db", engine: "postgres" }) \u2192 { database: { id: 42, publicId: "db_\u2026", status: "creating" } }'
+  ].join("\n"),
+  input: {
+    project_id: z5.union([z5.number().int().positive(), z5.string()]).describe('Target project \u2014 numeric id or publicId ("prj_\u2026").'),
+    name: z5.string().min(1).max(100).describe("Database name (1\u2013100 chars)."),
+    engine: z5.enum(DB_ENGINES).describe("Database engine."),
+    version: z5.string().max(20).optional().describe(`Engine version. ${VERSION_HELP}. Omit for the engine default.`),
+    plan: z5.enum(["micro", "starter", "standard", "pro"]).optional().describe('Plan tier (memory/CPU). Default "starter".'),
+    environment_id: z5.union([z5.number().int().positive(), z5.string()]).optional().describe("Environment to bind to. Defaults to the project Production env."),
+    postgis: z5.boolean().optional().describe("Postgres only \u2014 enable the PostGIS extension image."),
+    pgvector: z5.boolean().optional().describe(
+      "Postgres only \u2014 enable the pgvector extension image. Exclusive with postgis."
+    )
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    const projectId = await ctx.hoststack.resolveId(args.project_id, {
+      kind: "project",
+      teamId
+    });
+    const input = {
+      name: args.name,
+      engine: args.engine,
+      projectId
+    };
+    if (args.version !== void 0) input.version = args.version;
+    if (args.plan !== void 0) input.plan = args.plan;
+    if (args.environment_id !== void 0) {
+      input.environmentId = await ctx.hoststack.resolveId(args.environment_id, {
+        kind: "environment",
+        teamId
+      });
+    }
+    if (args.postgis !== void 0) input.postgis = args.postgis;
+    if (args.pgvector !== void 0) input.pgvector = args.pgvector;
+    const response = await ctx.hoststack.databases.create(teamId, input);
+    const data = { database: shapeDatabase(response.database) };
+    const db = response.database;
+    return respond({
+      summary: `Created ${args.engine} database "${args.name}" (${db.publicId ?? "unknown"}, numeric id ${db.id ?? "?"}) \u2014 status ${db.status ?? "creating"}. Poll get_database until status=available, then link_resource_to_service to inject its URL into a service.`,
+      data
+    });
+  }
+});
+defineTool({
+  name: "delete_database",
+  category: "databases",
+  description: [
+    "Permanently delete a managed database \u2014 the container, its volume, and ALL data it holds.",
+    "",
+    'When to use: the user has explicitly asked to destroy a database they no longer want. This is irreversible and takes the data with it \u2014 confirm with the user before calling, and never call it to "clean up" as a side effect of another task. If the goal is to stop paying for an idle database while keeping the data, use suspend_database instead.',
+    "",
+    "Any service still linked to this database will lose the injected connection vars on its next deploy, and will fail at runtime if it depends on them. Check which services consume it first \u2014 the dashboard shows this under the database's Linked Services tab.",
+    "",
+    "Inputs:",
+    '  - database_id: publicId of the database (e.g. "db_\u2026").',
+    "",
+    "Returns: { ok: true }.",
+    "",
+    'Example: delete_database({ database_id: "db_abc" }) \u2192 { ok: true }'
+  ].join("\n"),
+  input: {
+    database_id: z5.string().describe("Database publicId (e.g. db_abc) to permanently delete.")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    await ctx.hoststack.databases.delete(teamId, args.database_id);
+    return respond({
+      summary: `Deleted database ${args.database_id} and all of its data. This cannot be undone.`
+    });
+  }
+});
+defineTool({
+  name: "suspend_database",
+  category: "databases",
+  description: [
+    "Suspend a managed database \u2014 stops its container while KEEPING the volume and all data. The reversible alternative to delete_database.",
+    "",
+    "When to use: a staging or preview database that nobody is using, to stop burning its compute tier. Connections fail while suspended; resume_database brings it back on the same connection URL.",
+    "",
+    "Inputs:",
+    '  - database_id: publicId of the database (e.g. "db_\u2026").',
+    "",
+    "Returns: { ok: true }.",
+    "",
+    'Example: suspend_database({ database_id: "db_abc" }) \u2192 { ok: true }'
+  ].join("\n"),
+  input: {
+    database_id: z5.string().describe("Database publicId (e.g. db_abc) to suspend.")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    await ctx.hoststack.databases.suspend(teamId, args.database_id);
+    return respond({
+      summary: `Suspended database ${args.database_id}. Data is preserved; resume_database restores it on the same URL.`
+    });
+  }
+});
+defineTool({
+  name: "resume_database",
+  category: "databases",
+  description: [
+    "Resume a suspended managed database \u2014 restarts its container against the existing volume. The connection URL is unchanged, so linked services do NOT need a redeploy.",
+    "",
+    "When to use: undoing a suspend_database, or bringing back a database that was suspended for non-payment once billing is resolved.",
+    "",
+    "Inputs:",
+    '  - database_id: publicId of the database (e.g. "db_\u2026").',
+    "",
+    'Returns: { ok: true }. Poll get_database until `status === "available"`.',
+    "",
+    'Example: resume_database({ database_id: "db_abc" }) \u2192 { ok: true }'
+  ].join("\n"),
+  input: {
+    database_id: z5.string().describe("Database publicId (e.g. db_abc) to resume.")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    await ctx.hoststack.databases.resume(teamId, args.database_id);
+    return respond({
+      summary: `Resume dispatched for ${args.database_id}. Poll get_database until status=available.`
+    });
+  }
+});
 defineTool({
   name: "list_databases",
   category: "databases",
   description: [
-    "List managed databases (Postgres, Redis, MySQL, MariaDB, MongoDB, Meilisearch, NATS) inside a project.",
+    "List managed databases (Postgres, Redis, MySQL, MariaDB, MongoDB) inside a project. Meilisearch and NATS are NOT databases \u2014 they are separate managed resources (search / queue) and do not appear here; see list_service_resources for what a service consumes.",
     "",
     "When to use: an agent needs to know what data stores exist in a project before connecting a service or running a migration. Pair with list_projects to discover project IDs.",
     "",
@@ -781,6 +976,34 @@ defineTool({
     });
   }
 });
+defineTool({
+  name: "restart_database",
+  category: "databases",
+  description: [
+    "Restart a managed database in place \u2014 `docker restart` of its container: same container, same volume, same connection URL. The database is briefly unavailable (a few seconds) while it bounces; no redeploy of connected services is needed.",
+    "",
+    "When to use: a database is wedged (stuck connection, needs to reload a config change, leaking memory) and a clean bounce is the fix \u2014 the database-equivalent of restarting a service.",
+    "",
+    "The database must be `available`. A suspended database has no running container (resume it first \u2192 409); a creating/migrating one is mid-operation (409). For a Patroni HA cluster this bounces the current leader, which triggers a normal failover while replicas keep serving reads.",
+    "",
+    "Inputs:",
+    "  - database_id: publicId of the database to restart.",
+    "",
+    "Returns: { ok: true } once the restart command reaches an agent (dispatched optimistically, like a service restart). Poll get_service_logs / get_database to confirm it came back.",
+    "",
+    'Example: restart_database({ database_id: "db_abc" }) \u2192 { ok: true }'
+  ].join("\n"),
+  input: {
+    database_id: z5.string().describe("Database publicId (e.g. db_abc) to restart.")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    await ctx.hoststack.databases.restart(teamId, args.database_id);
+    return respond({
+      summary: `Restart dispatched for ${args.database_id}. It will be briefly unavailable while the container bounces.`
+    });
+  }
+});
 defineTool({
   name: "get_database_cluster",
   category: "databases",
@@ -906,7 +1129,7 @@ defineTool({
   description: [
     "Cancel a running deploy. Stops the build/deploy pipeline mid-flight; the previously live revision keeps serving traffic.",
     "",
-    "When to use: the user notices a bad commit was pushed and wants to abort before it lands, or a build is hanging. Has no effect on already-finished deploys.",
+    "When to use: the user notices a bad commit was pushed and wants to abort before it lands, or a build is hanging. Also the right call for a deploy stuck in `deploying` because the new container is crash-looping against its health check \u2014 that state is cancellable and cancelling it frees the service (and the build queue) immediately instead of waiting out the grace period. Has no effect on already-finished deploys.",
     "",
     "Inputs:",
     "  - service_id: publicId of the service.",
@@ -1054,11 +1277,21 @@ defineTool({
 
 // src/tools/dns-records.ts
 import { z as z7 } from "zod";
-var DNS_RECORD_TYPES = ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV", "CAA", "ALIAS"];
-async function resolveZonePublicId(api, teamId, input) {
+var DNS_RECORD_TYPES = [
+  "A",
+  "AAAA",
+  "CNAME",
+  "MX",
+  "TXT",
+  "NS",
+  "SRV",
+  "CAA",
+  "ALIAS"
+];
+async function resolveZonePublicId(hoststack, teamId, input) {
   if (input.zone_id) {
-    const { zones: zones2 } = await api.get(`/api/dns-zones/${teamId}`);
-    const match = zones2.find((z15) => z15.publicId === input.zone_id);
+    const { zones: zones2 } = await hoststack.dns.listZones(teamId);
+    const match = zones2.find((z16) => z16.publicId === input.zone_id);
     if (!match) {
       throw new Error(`Zone ${input.zone_id} not found on this team.`);
     }
@@ -1067,12 +1300,12 @@ async function resolveZonePublicId(api, teamId, input) {
   if (!input.domain) {
     throw new Error("Provide either zone_id or domain.");
   }
-  const { zones } = await api.get(`/api/dns-zones/${teamId}`);
+  const { zones } = await hoststack.dns.listZones(teamId);
   const fqdn = input.domain.toLowerCase().replace(/\.$/, "");
   const labels = fqdn.split(".");
   for (let i = 0; i < labels.length - 1; i++) {
     const candidate = labels.slice(i).join(".");
-    const match = zones.find((z15) => z15.domainName.toLowerCase() === candidate);
+    const match = zones.find((z16) => z16.domainName.toLowerCase() === candidate);
     if (match && match.status !== "deleting") {
       return { publicId: match.publicId, domainName: match.domainName };
     }
@@ -1096,7 +1329,7 @@ defineTool({
   input: {},
   handler: async (_args, ctx) => {
     const teamId = await ctx.resolveTeamId();
-    const response = await ctx.api.get(`/api/dns-zones/${teamId}`);
+    const response = await ctx.hoststack.dns.listZones(teamId);
     const items = Array.isArray(response.zones) ? response.zones.map(shape) : [];
     const summary = items.length === 0 ? "No DNS zones hosted on this team. Create one in the dashboard (Domains \u2192 DNS)." : `Found ${items.length} hosted DNS zone${items.length === 1 ? "" : "s"}.`;
     return respond({ summary, data: { items } });
@@ -1125,10 +1358,8 @@ defineTool({
     const zoneInput = {};
     if (args.zone_id !== void 0) zoneInput.zone_id = args.zone_id;
     if (args.domain !== void 0) zoneInput.domain = args.domain;
-    const zone = await resolveZonePublicId(ctx.api, teamId, zoneInput);
-    const response = await ctx.api.get(
-      `/api/dns-zones/${teamId}/${zone.publicId}/records`
-    );
+    const zone = await resolveZonePublicId(ctx.hoststack, teamId, zoneInput);
+    const response = await ctx.hoststack.dns.listRecords(teamId, zone.publicId);
     const items = Array.isArray(response.records) ? response.records.map(shape) : [];
     const summary = items.length === 0 ? `Zone ${zone.domainName} has no records yet.` : `Returned ${items.length} record${items.length === 1 ? "" : "s"} for ${zone.domainName}.`;
     return respond({
@@ -1157,11 +1388,9 @@ defineTool({
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
-    const { zones } = await ctx.api.get(`/api/dns-zones/${teamId}`);
+    const { zones } = await ctx.hoststack.dns.listZones(teamId);
     for (const zone of zones) {
-      const { records } = await ctx.api.get(
-        `/api/dns-zones/${teamId}/${zone.publicId}/records`
-      );
+      const { records } = await ctx.hoststack.dns.listRecords(teamId, zone.publicId);
       const match = records.find((r) => r.publicId === args.record_id);
       if (match) {
         return respond({
@@ -1217,7 +1446,7 @@ defineTool({
     const zoneInput = {};
     if (args.zone_id !== void 0) zoneInput.zone_id = args.zone_id;
     if (args.domain !== void 0) zoneInput.domain = args.domain;
-    const zone = await resolveZonePublicId(ctx.api, teamId, zoneInput);
+    const zone = await resolveZonePublicId(ctx.hoststack, teamId, zoneInput);
     const body = {
       type: args.type,
       name: args.name,
@@ -1225,10 +1454,7 @@ defineTool({
     };
     if (args.ttl !== void 0) body.ttl = args.ttl;
     if (args.priority !== void 0) body.priority = args.priority;
-    const response = await ctx.api.post(
-      `/api/dns-zones/${teamId}/${zone.publicId}/records`,
-      body
-    );
+    const response = await ctx.hoststack.dns.createRecord(teamId, zone.publicId, body);
     return respond({
       summary: `Created ${args.type} ${args.name} on ${zone.domainName}.`,
       data: {
@@ -1268,7 +1494,7 @@ defineTool({
       return respondError(`Priority is required for ${args.type} records (0\u201365535).`);
     }
     const teamId = await ctx.resolveTeamId();
-    const target = await findRecordZone(ctx.api, teamId, args.record_id);
+    const target = await findRecordZone(ctx.hoststack, teamId, args.record_id);
     if (!target) {
       return respondError(
         `Record ${args.record_id} not found on any zone owned by this team.`
@@ -1281,8 +1507,10 @@ defineTool({
     };
     if (args.ttl !== void 0) body.ttl = args.ttl;
     if (args.priority !== void 0) body.priority = args.priority;
-    const response = await ctx.api.put(
-      `/api/dns-zones/${teamId}/${target.zone.publicId}/records/${args.record_id}`,
+    const response = await ctx.hoststack.dns.updateRecord(
+      teamId,
+      target.zone.publicId,
+      args.record_id,
       body
     );
     return respond({
@@ -1317,27 +1545,66 @@ defineTool({
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
-    const target = await findRecordZone(ctx.api, teamId, args.record_id);
+    const target = await findRecordZone(ctx.hoststack, teamId, args.record_id);
     if (!target) {
       return respondError(
         `Record ${args.record_id} not found on any zone owned by this team.`
       );
     }
-    await ctx.api.delete(
-      `/api/dns-zones/${teamId}/${target.zone.publicId}/records/${args.record_id}`
-    );
+    await ctx.hoststack.dns.deleteRecord(teamId, target.zone.publicId, args.record_id);
     return respond({
       summary: `Deleted record ${args.record_id} from ${target.zone.domainName}.`,
       data: { ok: true }
     });
   }
 });
-async function findRecordZone(api, teamId, recordPublicId) {
-  const { zones } = await api.get(`/api/dns-zones/${teamId}`);
-  for (const zone of zones) {
-    const { records } = await api.get(
-      `/api/dns-zones/${teamId}/${zone.publicId}/records`
+defineTool({
+  name: "resync_dns_record",
+  category: "dns",
+  description: [
+    'Re-push a DNS record to PowerDNS without changing its value. Recovers a record stuck at status="failed" after a transient provider outage \u2014 including managedBy="hoststack" records (auto-created for a service/domain) that create/update/delete refuse to touch.',
+    "",
+    `When to use: a record shows status="failed" with a lastSyncError, or a freshly-attached domain's auto-created A record never went active. Safe and idempotent \u2014 a rejected re-push leaves the live RRset untouched (PowerDNS PATCH is atomic), so this can never drop a working record.`,
+    "",
+    "Inputs:",
+    '  - record_id: record publicId (e.g. "dnr_abc").',
+    "",
+    'Returns: { record: Record } \u2014 the record with its refreshed status ("active" on success).',
+    "",
+    'Example: resync_dns_record({ record_id: "dnr_abc" }) \u2192 { record: { status: "active", ... } }'
+  ].join("\n"),
+  input: {
+    record_id: z7.string().describe("Record publicId.")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    const target = await findRecordZone(ctx.hoststack, teamId, args.record_id);
+    if (!target) {
+      return respondError(
+        `Record ${args.record_id} not found on any zone owned by this team.`
+      );
+    }
+    const response = await ctx.hoststack.dns.resyncRecord(
+      teamId,
+      target.zone.publicId,
+      args.record_id
     );
+    return respond({
+      summary: `Re-synced record ${args.record_id} on ${target.zone.domainName} (status: ${response.record.status}).`,
+      data: {
+        zone: {
+          publicId: target.zone.publicId,
+          domainName: target.zone.domainName
+        },
+        record: shape(response.record)
+      }
+    });
+  }
+});
+async function findRecordZone(hoststack, teamId, recordPublicId) {
+  const { zones } = await hoststack.dns.listZones(teamId);
+  for (const zone of zones) {
+    const { records } = await hoststack.dns.listRecords(teamId, zone.publicId);
     const match = records.find((r) => r.publicId === recordPublicId);
     if (match) return { zone, record: match };
   }
@@ -1397,9 +1664,10 @@ defineTool({
     };
     if (args.path_prefix !== void 0) input.pathPrefix = args.path_prefix;
     const response = await ctx.hoststack.domains.add(teamId, input);
-    const data = { domain: shapeDomain(response.domain) };
+    const dnsSyncWarning = response.domain.dnsSyncWarning;
+    const data = dnsSyncWarning ? { domain: shapeDomain(response.domain), dnsSyncWarning } : { domain: shapeDomain(response.domain) };
     return respond({
-      summary: `Added domain ${args.hostname}. Configure DNS, then call verify_domain.`,
+      summary: dnsSyncWarning ? `Added domain ${args.hostname}, but its auto-created DNS record hasn't synced yet \u2014 ${dnsSyncWarning}` : `Added domain ${args.hostname}. Configure DNS, then call verify_domain.`,
       data
     });
   }
@@ -1497,6 +1765,7 @@ defineTool({
     '  - key: env-var name (e.g. "DATABASE_URL").',
     "  - value: new value (will be encrypted at rest if is_secret=true).",
     "  - is_secret (optional): true marks the value as secret (masked on read). On create, defaults to true for safety. On update, omitting it leaves the existing flag untouched \u2014 pass it explicitly only when you want to change classification.",
+    '  - target (optional): where the var is injected \u2014 "build", "runtime", or "both". On create, defaults to "both". On update, omitting it leaves the existing target untouched.',
     "",
     'Returns: { envVar: EnvVar, action: "created" | "updated" }.',
     "",
@@ -1506,7 +1775,8 @@ defineTool({
     service_id: z9.string().describe("Service publicId."),
     key: z9.string().min(1).max(128).describe("Env-var key."),
     value: z9.string().describe("New value."),
-    is_secret: z9.boolean().optional().describe("Mark as secret (encrypted, masked on read). Default true.")
+    is_secret: z9.boolean().optional().describe("Mark as secret (encrypted, masked on read). Default true."),
+    target: z9.enum(["build", "runtime", "both"]).optional().describe("Injection target: build, runtime, or both. Default both.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -1515,6 +1785,7 @@ defineTool({
     if (match) {
       const updatePayload = { value: args.value };
       if (args.is_secret !== void 0) updatePayload.isSecret = args.is_secret;
+      if (args.target !== void 0) updatePayload.target = args.target;
       const response2 = await ctx.hoststack.envVars.update(
         teamId,
         args.service_id,
@@ -1530,7 +1801,8 @@ defineTool({
     const response = await ctx.hoststack.envVars.create(teamId, args.service_id, {
       key: args.key,
       value: args.value,
-      isSecret: args.is_secret ?? true
+      isSecret: args.is_secret ?? true,
+      ...args.target !== void 0 ? { target: args.target } : {}
     });
     const data = {
       envVar: shapeEnvVar(response.envVar),
@@ -1586,7 +1858,7 @@ defineTool({
     "",
     "Inputs:",
     "  - service_id: publicId of the service.",
-    "  - env_vars: array of { key, value, is_secret? }. is_secret defaults to true per row.",
+    '  - env_vars: array of { key, value, is_secret?, target? }. is_secret defaults to FALSE per row (a row is stored in the clear unless you set is_secret:true); target defaults to "both". Note this differs from set_env_var, which defaults a newly-created var to secret.',
     "",
     "Returns: { ok: true }. Re-list with list_env_vars to confirm the new state.",
     "",
@@ -1598,7 +1870,8 @@ defineTool({
       z9.object({
         key: z9.string().min(1).max(128),
         value: z9.string(),
-        is_secret: z9.boolean().optional()
+        is_secret: z9.boolean().optional(),
+        target: z9.enum(["build", "runtime", "both"]).optional()
       })
     ).max(500).describe("Array of env-var rows. Hard cap 500.")
   },
@@ -1611,6 +1884,7 @@ defineTool({
           value: v.value
         };
         if (v.is_secret !== void 0) row.isSecret = v.is_secret;
+        if (v.target !== void 0) row.target = v.target;
         return row;
       })
     };
@@ -1632,6 +1906,10 @@ defineTool({
     "",
     "When to use: the user wants to see what envs exist before creating a service in one or promoting a deploy. Every project has at least Production.",
     "",
+    // §2.2: these are project deployment environments, not cloud Dev Boxes — point agents at the
+    // right surface so the two "dev" concepts stay distinct (bidirectional cross-reference).
+    "NOTE \u2014 these are project deployment environments (Production / Staging / Preview), NOT agentic cloud Dev Boxes. To list Dev Boxes use list_dev_environments; to create one use create_dev_environment / create_standalone_dev_environment / spin_up_dev_environment.",
+    "",
     "Inputs:",
     '  - project_id: project publicId (e.g. "prj_abc123").',
     "",
@@ -1658,10 +1936,15 @@ defineTool({
     "",
     "When to use: the user wants to add an env so they can run a sibling service alongside production for testing or staging before release.",
     "",
+    // §2.1/§2.2: steer callers away from the agentic cloud Dev Box tools (which live in
+    // services.ts) — an environment is a deployment target, NOT a Dev Box. Bidirectional with
+    // the cross-references those dev-box tools point back here.
+    'NOTE \u2014 this is NOT a cloud Dev Box. An environment is a project deployment target (Production / Staging / Preview); type="development" just gives services a -dev hostname suffix. For an agentic cloud Dev Box (a terminal you drive coding agents in) use create_dev_environment / create_standalone_dev_environment / spin_up_dev_environment instead.',
+    "",
     "Inputs:",
     "  - project_id: project publicId.",
     "  - name: human-readable name (1\u201364 chars). Shown in the env switcher.",
-    '  - type: "production" | "staging" | "development" | "preview". Determines the hostname suffix on services in this env (production stays clean; others get -staging / -dev / -preview).',
+    '  - type: "production" | "staging" | "development" | "preview". Determines the hostname suffix on services in this env (production stays clean; others get -staging / -dev / -preview). type="development" creates a PROJECT deployment environment (a -dev hostname suffix), NOT an agentic Dev Box \u2014 for a cloud dev box use create_dev_environment / create_standalone_dev_environment / spin_up_dev_environment.',
     "  - is_protected (optional): require admin role for destructive actions in this env. Default false.",
     "",
     "Returns: { environment: Environment }.",
@@ -1671,7 +1954,10 @@ defineTool({
   input: {
     project_id: z10.string().describe("Project publicId."),
     name: z10.string().min(1).max(64).describe("Environment name (1\u201364 chars)."),
-    type: z10.enum(["production", "staging", "development", "preview"]).describe("Environment type \u2014 drives the hostname suffix."),
+    type: z10.enum(["production", "staging", "development", "preview"]).describe(
+      // §2.1: "development" here is a project deployment env, NOT a cloud Dev Box.
+      'Environment type \u2014 drives the hostname suffix. type="development" creates a PROJECT deployment environment (a -dev hostname suffix), NOT an agentic Dev Box \u2014 for a cloud dev box use create_dev_environment / create_standalone_dev_environment / spin_up_dev_environment.'
+    ),
     is_protected: z10.boolean().optional().describe("Require admin role for destructive actions. Default false.")
   },
   handler: async (args, ctx) => {
@@ -1762,7 +2048,57 @@ defineTool({
   }
 });
 
+// src/tools/github.ts
+defineTool({
+  name: "sync_github_repos",
+  category: "github",
+  description: [
+    "Re-sync the repository list from GitHub for every connected GitHub App installation.",
+    "",
+    "When to use: right after pushing a brand-new repository, HostStack cannot see it until an installation re-sync runs \u2014 so create_service with a github_repo_id would fail. Call this first. (Same operation as the dashboard's refresh icon on the repo picker.)",
+    "",
+    "No inputs.",
+    "",
+    "Returns: { installations: number, repos: [{ account, count }], totalRepos } \u2014 the accounts synced and how many repos each now exposes.",
+    "",
+    'Example: sync_github_repos({}) \u2192 { installations: 1, repos: [{ account: "acme", count: 12 }], totalRepos: 12 }'
+  ].join("\n"),
+  input: {},
+  handler: async (_args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    const { installations } = await ctx.api.get(
+      `/api/github/${teamId}/installations`
+    );
+    if (installations.length === 0) {
+      return respondError(
+        "No GitHub installations connected. Install the HostStack GitHub App from the dashboard (Settings \u2192 GitHub) first."
+      );
+    }
+    const perAccount = [];
+    let totalRepos = 0;
+    for (const inst of installations) {
+      const { repos } = await ctx.api.post(
+        `/api/github/${teamId}/installations/${inst.id}/sync`
+      );
+      perAccount.push({ account: inst.accountLogin, count: repos.length });
+      totalRepos += repos.length;
+    }
+    return respond({
+      summary: `Synced ${totalRepos} repositories across ${installations.length} installation(s).`,
+      data: { installations: installations.length, repos: perAccount, totalRepos }
+    });
+  }
+});
+
 // src/tools/meta.ts
+var DEV_ENV_TOOL_NAMES = [
+  "create_dev_environment",
+  "create_standalone_dev_environment",
+  "spin_up_dev_environment",
+  "list_dev_environments",
+  "resize_dev_environment",
+  "delete_dev_environment"
+];
 defineTool({
   name: "get_me",
   category: "meta",
@@ -1787,6 +2123,36 @@ defineTool({
     return respond({ summary: `Authenticated as ${userEmail}${teamLabel}.`, data });
   }
 });
+defineTool({
+  name: "describe_mcp",
+  category: "meta",
+  description: [
+    "Report this MCP build: its package version, total tool count, and the list of Dev Box tools it exposes. Read-only \u2014 touches no account data.",
+    "",
+    "When to use: at the start of a session to confirm the live MCP build, OR when a Dev Box tool you expect (create_dev_environment, create_standalone_dev_environment, spin_up_dev_environment, list_dev_environments, resize_dev_environment, delete_dev_environment) seems to be missing. A STALE npx/npm cache can silently present an old tool set with no other signal \u2014 call this and check `devEnvToolsPresent`; if it is false, the cached build predates the Dev Box tools and the user should refresh it (e.g. `npx --yes @hoststack.dev/mcp@latest` / clear the npx cache).",
+    "",
+    'Note on terminology: a "Dev Box" (a.k.a. Cloud Dev Box) is an agentic cloud box you code inside (create_dev_environment & friends). It is NOT a project "environment" (create_environment), which is a deployment target like Production / Staging / Preview. This tool only reports the Dev Box tool set.',
+    "",
+    "Inputs: none.",
+    "",
+    "Returns: { version, toolCount, devEnvTools: string[], devEnvToolsPresent: boolean } \u2014 version is the @hoststack.dev/mcp package version, toolCount is every registered tool, devEnvTools is the expected Dev Box tool names, and devEnvToolsPresent is true only if all of them are actually registered in this build.",
+    "",
+    'Example: describe_mcp() \u2192 { version: "0.14.0", toolCount: 30, devEnvTools: ["create_dev_environment", \u2026], devEnvToolsPresent: true }'
+  ].join("\n"),
+  input: {},
+  handler: async (_args, _ctx) => {
+    const registered = new Set(listToolDefinitions().map((t) => t.name));
+    const devEnvToolsPresent = DEV_ENV_TOOL_NAMES.every((name) => registered.has(name));
+    const data = {
+      version: MCP_VERSION,
+      toolCount: registered.size,
+      devEnvTools: [...DEV_ENV_TOOL_NAMES],
+      devEnvToolsPresent
+    };
+    const summary = devEnvToolsPresent ? `hoststack MCP v${MCP_VERSION} \u2014 ${data.toolCount} tools, all ${DEV_ENV_TOOL_NAMES.length} Dev Box tools present.` : `hoststack MCP v${MCP_VERSION} \u2014 ${data.toolCount} tools, but Dev Box tools are MISSING (stale build \u2014 refresh the npx/npm cache).`;
+    return respond({ summary, data });
+  }
+});
 
 // src/tools/notifications.ts
 import { z as z11 } from "zod";
@@ -1802,7 +2168,10 @@ var NOTIFICATION_EVENTS = [
   "service.restart_failed",
   "service.auto_suspended",
   "service.acme_cert_failed",
-  "git.auth_failed"
+  "service.resource_alert",
+  "git.auth_failed",
+  "cron.execution_failed",
+  "workflow.failed"
 ];
 defineTool({
   name: "list_notification_channels",
@@ -1841,7 +2210,7 @@ defineTool({
     "  - webhook_url: Slack/Discord webhook URL OR email address.",
     "  - events: list of event names to subscribe to. Pass an empty list to create a channel that fires for nothing (manual subscribe later with update_notification_channel).",
     "",
-    "Valid events: deploy.started, deploy.succeeded, deploy.failed, deploy.failed_consecutive, service.created, service.deleted, service.suspended, service.resumed, service.restart_failed, service.auto_suspended, service.acme_cert_failed, git.auth_failed.",
+    "Valid events: deploy.started, deploy.succeeded, deploy.failed, deploy.failed_consecutive, service.created, service.deleted, service.suspended, service.resumed, service.restart_failed, service.auto_suspended, service.acme_cert_failed, service.resource_alert, git.auth_failed, cron.execution_failed, workflow.failed.",
     "",
     "Returns: { channel: Channel }.",
     "",
@@ -2096,9 +2465,159 @@ defineTool({
   }
 });
 
-// src/tools/services.ts
+// src/tools/resource-links.ts
 import { z as z13 } from "zod";
-var DEV_ENV_IMAGE = "hoststack/dev-env:latest";
+var RESOURCE_LINK_TYPES = [
+  "database",
+  "object_storage",
+  "queue",
+  "search",
+  "email_domain"
+];
+var INJECTION_CONTRACT = [
+  "What a link injects at deploy time:",
+  '  - Alias-prefixed vars for every field of the resource (alias "APP_DB" \u2192 APP_DB_HOST, APP_DB_PORT, APP_DB_USER, APP_DB_PASSWORD, APP_DB_URL, \u2026). This is how one service consumes several resources of the same type without collisions.',
+  "  - PLUS the conventional name for the first linked resource of each engine class: `DATABASE_URL` (postgres/mysql/mariadb), `REDIS_URL` (redis), `MONGO_URL` (mongodb). So an app reading `process.env.DATABASE_URL` works with no code changes.",
+  "  - The conventional names are set with `??=` \u2014 an env var you set yourself via set_env_var ALWAYS wins over the injected one."
+].join("\n");
+defineTool({
+  name: "list_managed_resources",
+  category: "resource-links",
+  description: [
+    "List EVERY managed resource the team owns in one call \u2014 databases, object storage buckets, queues, search indexes and email domains \u2014 from the unified `managed_resources` read-model.",
+    "",
+    'When to use: to find the NUMERIC `id` that link_resource_to_service needs, especially for resource types with no dedicated list tool of their own (object storage, queues, search, email domains \u2014 list_databases only covers databases). Also a fast inventory answer for "what do we actually have running".',
+    "",
+    "Team-wide, not project-scoped. Use list_databases when you specifically want databases in one project.",
+    "",
+    "Returns: { items: ManagedResource[] } \u2014 id (numeric, for linking), publicId, type, name, status, region, createdAt.",
+    "",
+    'Example: list_managed_resources() \u2192 { items: [{ id: 42, type: "database", name: "app-db", status: "available" }, { id: 8, type: "object_storage", name: "uploads", \u2026 }] }'
+  ].join("\n"),
+  input: {},
+  handler: async (_args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    const response = await ctx.hoststack.serviceResourceLinks.listManagedResources(teamId);
+    const data = shapeList(response, "resources", shape);
+    const byType = /* @__PURE__ */ new Map();
+    for (const item of data.items) {
+      const type = item && typeof item === "object" && "type" in item ? String(item.type) : "unknown";
+      byType.set(type, (byType.get(type) ?? 0) + 1);
+    }
+    const breakdown = [...byType.entries()].map(([t, n]) => `${n} ${t}`).join(", ");
+    const summary = data.items.length === 0 ? "No managed resources on this team yet." : `${data.items.length} managed resource${data.items.length === 1 ? "" : "s"}: ${breakdown}.`;
+    return respond({ summary, data });
+  }
+});
+defineTool({
+  name: "list_service_resources",
+  category: "resource-links",
+  description: [
+    "List the managed resources (databases, object storage, queues, search, email domains) linked to a service \u2014 i.e. which resources get injected into its container as env vars on deploy.",
+    "",
+    'When to use: before adding a link (to avoid a duplicate or an alias collision), when debugging "why is DATABASE_URL empty in my app" (the answer is usually: no link exists, or the service was never redeployed after linking), or to find the linkId needed by unlink_resource_from_service.',
+    "",
+    INJECTION_CONTRACT,
+    "",
+    "Inputs:",
+    '  - service_id: publicId ("svc_\u2026") or numeric id of the service.',
+    "",
+    "Returns: { items: ServiceResourceLink[] } \u2014 id (the linkId), resourceType, resourceId (numeric id of the linked resource), alias, createdAt.",
+    "",
+    'Example: list_service_resources({ service_id: "svc_abc" }) \u2192 { items: [{ id: 7, resourceType: "database", resourceId: 42, alias: "APP_DB" }] }'
+  ].join("\n"),
+  input: {
+    service_id: z13.union([z13.number().int().positive(), z13.string()]).describe('Service \u2014 publicId ("svc_\u2026") or numeric id.')
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    const response = await ctx.hoststack.serviceResourceLinks.list(teamId, args.service_id);
+    const data = shapeList(response, "links", shape);
+    const summary = data.items.length === 0 ? `No resources linked to service ${args.service_id}. Nothing is being injected \u2014 link a database with link_resource_to_service.` : `${data.items.length} resource${data.items.length === 1 ? "" : "s"} linked to service ${args.service_id}.`;
+    return respond({ summary, data });
+  }
+});
+defineTool({
+  name: "link_resource_to_service",
+  category: "resource-links",
+  description: [
+    "Link a managed resource to a service so its connection details are injected into the container as environment variables. This is the step that connects a database to an app \u2014 creating the database alone does nothing for the app.",
+    "",
+    "When to use: immediately after create_database (or when pointing an existing service at an existing resource). This is step 2 of 3 in the managed-database flow: create_database \u2192 link_resource_to_service \u2192 trigger_deploy.",
+    "",
+    '*** The link takes effect on the NEXT DEPLOY. *** After calling this, call trigger_deploy({ service_id }) or the running container will not see the new vars. A service that "cannot connect to the database" right after linking almost always just needs that redeploy.',
+    "",
+    INJECTION_CONTRACT,
+    "",
+    "Because the platform injects the credentials directly into the container, you do NOT need to read the password, build a connection string by hand, or store it with set_env_var. Don't.",
+    "",
+    "Inputs:",
+    '  - service_id: publicId ("svc_\u2026") or numeric id of the consuming service.',
+    `  - resource_type: ${RESOURCE_LINK_TYPES.join(" | ")}.`,
+    '  - resource_id: the NUMERIC id of the resource \u2014 e.g. the `id` field from create_database / list_databases, NOT the "db_\u2026" publicId.',
+    '  - alias: uppercase env-var prefix (A\u2013Z, 0\u20139, underscore; must start with a letter; \u226448 chars), e.g. "APP_DB", "CACHE", "CATALOG". Must be unique within the service.',
+    "",
+    "Returns: { link: ServiceResourceLink } \u2014 including `id`, the linkId used to unlink later.",
+    "",
+    "Fails with 409 if this exact resource is already linked to the service, or if the alias is already taken on it.",
+    "",
+    'Example: link_resource_to_service({ service_id: "svc_abc", resource_type: "database", resource_id: 42, alias: "APP_DB" }) \u2192 { link: { id: 7, alias: "APP_DB" } }'
+  ].join("\n"),
+  input: {
+    service_id: z13.union([z13.number().int().positive(), z13.string()]).describe('Consuming service \u2014 publicId ("svc_\u2026") or numeric id.'),
+    resource_type: z13.enum(RESOURCE_LINK_TYPES).describe("Kind of resource being linked."),
+    resource_id: z13.number().int().positive().describe("NUMERIC id of the resource (e.g. database.id) \u2014 not the publicId."),
+    alias: z13.string().min(1).max(48).regex(
+      /^[A-Z][A-Z0-9_]*$/,
+      "Alias must be uppercase letters, digits and underscores, starting with a letter."
+    ).describe('Uppercase env-var prefix, e.g. "APP_DB". Unique within the service.')
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    const response = await ctx.hoststack.serviceResourceLinks.create(teamId, args.service_id, {
+      resourceType: args.resource_type,
+      resourceId: args.resource_id,
+      alias: args.alias
+    });
+    const data = { link: shape(response.link) };
+    return respond({
+      summary: `Linked ${args.resource_type} ${args.resource_id} to service ${args.service_id} as "${args.alias}". Call trigger_deploy({ service_id: "${args.service_id}" }) to inject it \u2014 the running container will not see the vars until then.`,
+      data
+    });
+  }
+});
+defineTool({
+  name: "unlink_resource_from_service",
+  category: "resource-links",
+  description: [
+    "Remove a resource link from a service. The resource itself is NOT deleted \u2014 only the binding.",
+    "",
+    "When to use: repointing a service at a different database, or detaching a resource a service no longer needs. The injected env vars disappear on the next deploy, so a service that still reads DATABASE_URL will break then, not immediately. Use delete_database if the intent is to destroy the data.",
+    "",
+    "Inputs:",
+    '  - service_id: publicId ("svc_\u2026") or numeric id of the service.',
+    "  - link_id: numeric linkId from list_service_resources (the `id` field on the link, not the resource id).",
+    "",
+    "Returns: { ok: true }.",
+    "",
+    'Example: unlink_resource_from_service({ service_id: "svc_abc", link_id: 7 }) \u2192 { ok: true }'
+  ].join("\n"),
+  input: {
+    service_id: z13.union([z13.number().int().positive(), z13.string()]).describe('Service \u2014 publicId ("svc_\u2026") or numeric id.'),
+    link_id: z13.number().int().positive().describe("Numeric linkId from list_service_resources (the link's own `id`).")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    await ctx.hoststack.serviceResourceLinks.delete(teamId, args.service_id, args.link_id);
+    return respond({
+      summary: `Unlinked resource link ${args.link_id} from service ${args.service_id}. The resource still exists; its env vars vanish on the next deploy.`
+    });
+  }
+});
+
+// src/tools/services.ts
+import { z as z14 } from "zod";
+var DEV_ENV_IMAGE = "registry.hoststack.dev/hoststack/dev-env:latest";
 var DEV_ENV_VOLUME = { name: "workspace", mountPath: "/workspace", sizeGb: 10 };
 var SERVICE_TYPES = [
   "web_service",
@@ -2111,11 +2630,19 @@ var SERVICE_PLANS = [
   "pico",
   "nano",
   "micro",
-  "starter",
+  "small",
   "standard",
+  "large",
+  "xlarge",
   "pro_standard",
   "pro_large"
 ];
+var DEV_ENV_MIN_SIZE = "standard";
+function coerceDevEnvSize(value) {
+  const minIdx = SERVICE_PLANS.indexOf(DEV_ENV_MIN_SIZE);
+  const idx = value ? SERVICE_PLANS.indexOf(value) : -1;
+  return idx >= minIdx ? value : DEV_ENV_MIN_SIZE;
+}
 defineTool({
   name: "list_services",
   category: "services",
@@ -2124,25 +2651,32 @@ defineTool({
     "",
     "When to use: the agent needs to find a service by name, check what is deployed, or pick a target for a follow-up tool (logs, deploys, env vars). This is the canonical way to resolve a publicId from a human-friendly name.",
     "",
+    "Note: agentic Dev Boxes (cloud dev environments) are EXCLUDED by default. Pass dev_environment:true to include them, or use list_dev_environments for the dedicated, annotated dev-box listing.",
+    "",
     "Inputs (all optional):",
     '  - project_id: narrow to one project (numeric id or publicId "prj_\u2026").',
     '  - environment_id: narrow to one environment (numeric id or publicId "env_\u2026").',
     '  - status: "active" | "deploying" | "suspended" | "failed" | "not_deployed".',
     '  - type: "web_service" | "private_service" | "worker" | "cron_job" | "static_site".',
+    "  - dev_environment: include Dev Boxes in the results (excluded by default).",
     "",
     "Returns: { items: Service[] } \u2014 each service includes id, publicId, name, type, status, projectId, repoUrl, branch, runtime, createdAt.",
     "",
     'Example: list_services({ status: "failed" }) \u2192 only services that need attention.'
   ].join("\n"),
   input: {
-    project_id: z13.union([z13.number().int().positive(), z13.string()]).optional().describe("Project filter \u2014 numeric id or publicId."),
-    environment_id: z13.union([z13.number().int().positive(), z13.string()]).optional().describe("Environment filter \u2014 numeric id or publicId."),
-    status: z13.enum(["active", "deploying", "suspended", "failed", "not_deployed"]).optional().describe("Filter by current runtime status."),
-    type: z13.enum(["web_service", "private_service", "worker", "cron_job", "static_site"]).optional().describe("Filter by service type.")
+    project_id: z14.union([z14.number().int().positive(), z14.string()]).optional().describe("Project filter \u2014 numeric id or publicId."),
+    environment_id: z14.union([z14.number().int().positive(), z14.string()]).optional().describe("Environment filter \u2014 numeric id or publicId."),
+    status: z14.enum(["active", "deploying", "suspended", "failed", "not_deployed"]).optional().describe("Filter by current runtime status."),
+    type: z14.enum(["web_service", "private_service", "worker", "cron_job", "static_site"]).optional().describe("Filter by service type."),
+    dev_environment: z14.boolean().optional().describe(
+      "Include agentic Dev Boxes in the results (excluded by default; see list_dev_environments)."
+    )
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
     const filters = {};
+    if (args.dev_environment) filters.devEnvironment = true;
     if (args.project_id !== void 0) {
       const resolved = await ctx.hoststack.resolveId(args.project_id, {
         kind: "project",
@@ -2165,7 +2699,8 @@ defineTool({
       args.project_id !== void 0 ? `project=${args.project_id}` : null,
       args.environment_id !== void 0 ? `env=${args.environment_id}` : null,
       args.status ? `status=${args.status}` : null,
-      args.type ? `type=${args.type}` : null
+      args.type ? `type=${args.type}` : null,
+      args.dev_environment ? "devBoxes=included" : null
     ].filter(Boolean).join(", ");
     const summary = data.items.length === 0 ? filterDesc ? `No services match the given filters (${filterDesc}).` : "No services yet \u2014 create one with create_service (or create_dev_environment for an AI dev box), or via the dashboard." : `Found ${data.items.length} service${data.items.length === 1 ? "" : "s"}${filterDesc ? ` matching ${filterDesc}` : ""}.`;
     return respond({ summary, data });
@@ -2179,6 +2714,8 @@ defineTool({
     "",
     "When to use: the user wants to deploy something new. For a one-command AI dev environment specifically, prefer create_dev_environment (it also attaches the /workspace volume and sets the MCP keys).",
     "",
+    '*** NOT for databases. *** If the user wants Postgres, Redis, MySQL, MariaDB or MongoDB, call create_database \u2014 do NOT create a service with docker_image "postgres:16" / "redis:7" / "mongo" / "mysql". A database deployed as a service is unmanaged: no backups, no version upgrades, no HA, no credential rotation, no metrics, no persistent volume, and nothing injects its URL into your app. `docker_image` here is for YOUR application images (or sidecars), not for datastores the platform already manages.',
+    "",
     "Inputs:",
     '  - project_id: numeric id or publicId ("prj_\u2026") of the target project.',
     "  - name: service name (1\u2013100 chars).",
@@ -2199,21 +2736,23 @@ defineTool({
     'Example: create_service({ project_id: "prj_abc", name: "api", type: "web_service", github_repo_id: 42 }) \u2192 { service: { publicId: "svc_\u2026" }, deployId: 1234 }'
   ].join("\n"),
   input: {
-    project_id: z13.union([z13.number().int().positive(), z13.string()]).describe("Target project \u2014 numeric id or publicId."),
-    name: z13.string().min(1).max(100).describe("Service name (1\u2013100 chars)."),
-    type: z13.enum(SERVICE_TYPES).describe("Service type."),
-    docker_image: z13.string().max(500).optional().describe("Pre-built image ref. Mutually exclusive with github_repo_id."),
-    github_repo_id: z13.number().int().positive().optional().describe("Linked GitHub repo numeric id. Mutually exclusive with docker_image."),
-    branch: z13.string().max(200).optional().describe('Git branch (default "main").'),
-    install_command: z13.string().max(1e3).optional().describe("Install shell command."),
-    build_command: z13.string().max(1e3).optional().describe("Build shell command."),
-    start_command: z13.string().max(1e3).optional().describe("Start shell command (required for web/private services without an image)."),
-    cron_schedule: z13.string().max(100).optional().describe("Cron expression \u2014 required for cron_job."),
-    publish_path: z13.string().max(500).optional().describe("Static-site output dir."),
-    runtime: z13.string().max(50).optional().describe("Runtime hint (node/bun/python/\u2026)."),
-    plan: z13.enum(SERVICE_PLANS).optional().describe('Service size (default "micro").'),
-    environment_id: z13.union([z13.number().int().positive(), z13.string()]).optional().describe("Bind to a specific environment; defaults to Production."),
-    auto_deploy: z13.boolean().optional().describe("Trigger the first deploy immediately (default true).")
+    project_id: z14.union([z14.number().int().positive(), z14.string()]).describe("Target project \u2014 numeric id or publicId."),
+    name: z14.string().min(1).max(100).describe("Service name (1\u2013100 chars)."),
+    type: z14.enum(SERVICE_TYPES).describe("Service type."),
+    docker_image: z14.string().max(500).optional().describe(
+      "Pre-built APPLICATION image ref. Mutually exclusive with github_repo_id. Not for databases \u2014 use create_database for postgres/redis/mysql/mariadb/mongodb."
+    ),
+    github_repo_id: z14.number().int().positive().optional().describe("Linked GitHub repo numeric id. Mutually exclusive with docker_image."),
+    branch: z14.string().max(200).optional().describe('Git branch (default "main").'),
+    install_command: z14.string().max(1e3).optional().describe("Install shell command."),
+    build_command: z14.string().max(1e3).optional().describe("Build shell command."),
+    start_command: z14.string().max(1e3).optional().describe("Start shell command (required for web/private services without an image)."),
+    cron_schedule: z14.string().max(100).optional().describe("Cron expression \u2014 required for cron_job."),
+    publish_path: z14.string().max(500).optional().describe("Static-site output dir."),
+    runtime: z14.string().max(50).optional().describe("Runtime hint (node/bun/python/\u2026)."),
+    plan: z14.enum(SERVICE_PLANS).optional().describe('Service size (default "micro").'),
+    environment_id: z14.union([z14.number().int().positive(), z14.string()]).optional().describe("Bind to a specific environment; defaults to Production."),
+    auto_deploy: z14.boolean().optional().describe("Trigger the first deploy immediately (default true).")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2256,14 +2795,16 @@ defineTool({
   name: "create_dev_environment",
   category: "services",
   description: [
-    "Spin up an AI dev environment in one call: a private service from the agentic dev-env image (Claude Code + Codex + OpenCode + MCPs preinstalled), with a persistent /workspace volume and the MCP API keys set, then fire the first deploy.",
+    'Spin up an AI Dev Box in one call: a cloud "Dev Box" (an agentic container from the dev-env image \u2014 Claude Code + Codex + OpenCode + MCPs preinstalled) inside a project, with a persistent /workspace volume and the MCP API keys set, then fire the first deploy.',
     "",
-    `When to use: the user wants a cloud terminal / dev box they can drive coding agents in (from a desk or a phone). This mirrors the dashboard's "AI Dev Environment" wizard preset \u2014 create (deploy deferred) \u2192 set keys \u2192 attach /workspace \u2192 deploy, so the first container boots with its volume and keys already in place.`,
+    'This makes a cloud Dev Box, NOT a project deploy environment. A project "environment" (create_environment \u2192 Production / Staging / Preview) is a deployment target; this is a workspace you code in. If you actually want a -dev deploy target, use create_environment instead.',
+    "",
+    `When to use: the user wants a cloud terminal / Dev Box they can drive coding agents in (from a desk or a phone). This mirrors the dashboard's "AI Dev Environment" wizard preset \u2014 create (deploy deferred) \u2192 set keys \u2192 attach /workspace \u2192 deploy, so the first container boots with its volume and keys already in place.`,
     "",
     "Inputs:",
     '  - project_id: numeric id or publicId ("prj_\u2026") of the target project.',
     '  - name (optional): service name (default "dev-environment").',
-    '  - plan (optional): service size (default "standard" \u2014 2 GB, the smallest that fits a coding agent + build).',
+    '  - plan (optional): box size. Defaults to "standard" (2 GB) \u2014 the OOM-safe floor (DEV_ENV_MIN_SIZE); a coding agent + build OOMs below it. A smaller plan is clamped up to "standard".',
     "  - disk_gb (optional): /workspace volume size in GB (default 10, 1\u2013100).",
     "  - hoststack_api_key (optional): sets HOSTSTACK_API_KEY so the hoststack MCP works inside the container.",
     "  - poststack_api_key (optional): sets POSTSTACK_API_KEY so the poststack MCP works inside the container.",
@@ -2274,18 +2815,18 @@ defineTool({
     'Example: create_dev_environment({ project_id: "prj_abc", name: "scratch", hoststack_api_key: "hs_live_\u2026" })'
   ].join("\n"),
   input: {
-    project_id: z13.union([z13.number().int().positive(), z13.string()]).describe("Target project \u2014 numeric id or publicId."),
-    name: z13.string().min(1).max(100).optional().describe('Service name (default "dev-environment").'),
-    plan: z13.enum(SERVICE_PLANS).optional().describe(
-      'Service size (default "standard" \u2014 2 GB; smallest that fits a coding agent).'
+    project_id: z14.union([z14.number().int().positive(), z14.string()]).describe("Target project \u2014 numeric id or publicId."),
+    name: z14.string().min(1).max(100).optional().describe('Service name (default "dev-environment").'),
+    plan: z14.enum(SERVICE_PLANS).optional().describe(
+      'Box size (default "standard" \u2014 2 GB, the OOM-safe floor; a smaller plan is clamped up to "standard").'
     ),
-    disk_gb: z13.number().int().min(1).max(100).optional().describe("/workspace volume size in GB (default 10)."),
-    hoststack_api_key: z13.string().optional().describe("Value for HOSTSTACK_API_KEY (enables the hoststack MCP in-container)."),
-    poststack_api_key: z13.string().optional().describe("Value for POSTSTACK_API_KEY (enables the poststack MCP in-container)."),
-    repo_url: z13.string().max(500).optional().describe(
+    disk_gb: z14.number().int().min(1).max(100).optional().describe("/workspace volume size in GB (default 10)."),
+    hoststack_api_key: z14.string().optional().describe("Value for HOSTSTACK_API_KEY (enables the hoststack MCP in-container)."),
+    poststack_api_key: z14.string().optional().describe("Value for POSTSTACK_API_KEY (enables the poststack MCP in-container)."),
+    repo_url: z14.string().max(500).optional().describe(
       "Clone this git URL into /workspace on first boot (HTTPS, or SSH once a key is set)."
     ),
-    branch: z13.string().max(200).optional().describe("Branch to clone (with repo_url).")
+    branch: z14.string().max(200).optional().describe("Branch to clone (with repo_url).")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2295,68 +2836,94 @@ defineTool({
     });
     const name = args.name ?? "dev-environment";
     const sizeGb = args.disk_gb ?? DEV_ENV_VOLUME.sizeGb;
+    const plan = coerceDevEnvSize(args.plan);
     const createInput = {
       name,
       type: "private_service",
       projectId,
       dockerImage: DEV_ENV_IMAGE,
-      autoDeploy: false
+      autoDeploy: false,
+      plan
     };
-    if (args.plan !== void 0) createInput.plan = args.plan;
     const created = await ctx.hoststack.services.create(teamId, createInput);
     const service = created.service;
-    const envVars = [];
-    if (args.hoststack_api_key)
-      envVars.push({
-        key: "HOSTSTACK_API_KEY",
-        value: args.hoststack_api_key,
-        isSecret: true
-      });
-    if (args.poststack_api_key)
-      envVars.push({
-        key: "POSTSTACK_API_KEY",
-        value: args.poststack_api_key,
-        isSecret: true
-      });
-    if (args.repo_url) {
-      envVars.push({
-        key: "HOSTSTACK_DEVENV_REPO_URL",
-        value: args.repo_url,
-        isSecret: false
-      });
-      if (args.branch)
+    const rollback = async () => {
+      try {
+        await ctx.hoststack.services.tearDownDevEnvironment(teamId, service.id);
+      } catch {
+        try {
+          await ctx.hoststack.services.delete(teamId, service.id);
+        } catch {
+        }
+      }
+    };
+    try {
+      const envVars = [];
+      if (args.hoststack_api_key)
         envVars.push({
-          key: "HOSTSTACK_DEVENV_BRANCH",
-          value: args.branch,
+          key: "HOSTSTACK_API_KEY",
+          value: args.hoststack_api_key,
+          isSecret: true
+        });
+      if (args.poststack_api_key)
+        envVars.push({
+          key: "POSTSTACK_API_KEY",
+          value: args.poststack_api_key,
+          isSecret: true
+        });
+      if (args.repo_url) {
+        envVars.push({
+          key: "HOSTSTACK_DEVENV_REPO_URL",
+          value: args.repo_url,
           isSecret: false
         });
-    }
-    if (envVars.length > 0) {
-      await ctx.hoststack.envVars.bulkSet(teamId, service.id, { vars: envVars });
-    }
-    let volumeAttached = false;
-    try {
-      await ctx.hoststack.volumes.create(teamId, service.id, {
-        name: DEV_ENV_VOLUME.name,
-        mountPath: DEV_ENV_VOLUME.mountPath,
-        sizeGb
+        if (args.branch)
+          envVars.push({
+            key: "HOSTSTACK_DEVENV_BRANCH",
+            value: args.branch,
+            isSecret: false
+          });
+      }
+      if (envVars.length > 0) {
+        await ctx.hoststack.envVars.bulkSet(teamId, service.id, { vars: envVars });
+      }
+      try {
+        await ctx.hoststack.volumes.create(teamId, service.id, {
+          name: DEV_ENV_VOLUME.name,
+          mountPath: DEV_ENV_VOLUME.mountPath,
+          sizeGb
+        });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        await rollback();
+        return respondError(
+          `Failed to attach the /workspace volume for Dev Box "${name}" \u2014 aborted and rolled back rather than deploy a box that would lose all work on recreate. Volume error: ${reason}`,
+          { volumeError: reason, rolledBack: true }
+        );
+      }
+      const deploy = await ctx.hoststack.deploys.trigger(teamId, service.id);
+      const deployId = deploy.deploy?.id ?? null;
+      return respond({
+        summary: `Created AI Dev Box "${name}" (${service.publicId}) with a /workspace volume \u2014 deploying. Open it in the dashboard's Dev Boxes section (or the service's Terminal tab) once running.`,
+        data: { service: shapeService(service), volumeAttached: true, deployId }
       });
-      volumeAttached = true;
-    } catch {
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      await rollback();
+      return respondError(
+        `Failed to provision Dev Box "${name}" \u2014 rolled back the partially-created box. Error: ${reason}`,
+        { rolledBack: true }
+      );
     }
-    const deploy = await ctx.hoststack.deploys.trigger(teamId, service.id);
-    const deployId = deploy.deploy?.id ?? null;
-    return respond({
-      summary: `Created AI dev environment "${name}" (${service.publicId})${volumeAttached ? " with a /workspace volume" : ""} \u2014 deploying. Open it in the dashboard's Development section (or the service's Terminal tab) once running.`,
-      data: { service: shapeService(service), volumeAttached, deployId }
-    });
   }
 });
 defineTool({
   name: "spin_up_dev_environment",
   category: "services",
   description: [
-    "Spin up an agentic dev environment FROM an existing service so you can reproduce a bug, fix it, view it, and ship it. Creates a dev box (Claude/Codex/OpenCode + MCPs) that RUNS a clone of the app: the repo is auto-cloned into /workspace, the service env-vars are copied, and its linked database is cloned (so the box never touches the prod DB). The box gets an unguessable public dev URL and seamless `git push`.",
+    "Spin up an agentic Dev Box FROM an existing service so you can reproduce a bug, fix it, view it, and ship it. Creates a cloud Dev Box (Claude/Codex/OpenCode + MCPs) that RUNS a clone of the app: the repo is auto-cloned into /workspace, the service env-vars are copied, and its linked database is cloned (so the box never touches the prod DB). The box gets an unguessable public dev URL and seamless `git push`.",
+    "",
+    "This makes a cloud Dev Box, NOT a project deploy environment \u2014 for a -dev/-staging deploy target use create_environment instead.",
     "",
     'When to use: "spin up a dev environment for <service>", "I found a bug on <service>, give me a box to fix it". Distinct from create_dev_environment, which makes a BARE box not tied to any app.',
     "",
@@ -2370,9 +2937,9 @@ defineTool({
     'Example: spin_up_dev_environment({ service_id: "svc_api" }) \u2192 a dev box running a clone of the api service (repo + env-vars + cloned DB) with a public dev URL.'
   ].join("\n"),
   input: {
-    service_id: z13.union([z13.number().int().positive(), z13.string()]).describe("Source service to debug \u2014 numeric id or publicId."),
-    include_database_clone: z13.boolean().optional().describe("Clone the linked database so the app runs on copied data (default true)."),
-    name: z13.string().min(1).max(100).optional().describe('Dev box name (default "<source>-dev").')
+    service_id: z14.union([z14.number().int().positive(), z14.string()]).describe("Source service to debug \u2014 numeric id or publicId."),
+    include_database_clone: z14.boolean().optional().describe("Clone the linked database so the app runs on copied data (default true)."),
+    name: z14.string().min(1).max(100).optional().describe('Dev box name (default "<source>-dev").')
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2399,7 +2966,9 @@ defineTool({
   name: "delete_dev_environment",
   category: "services",
   description: [
-    "Tear down an agentic dev environment in one call: removes the dev box AND cascade-deletes its cloned database, its /workspace volume, and the auto-created `development` environment if it is now empty.",
+    "Tear down an agentic Dev Box in one call: removes the cloud Dev Box AND cascade-deletes its cloned database, its /workspace volume, and the auto-created `development` environment if it is now empty.",
+    "",
+    "This deletes a cloud Dev Box, NOT a project deploy environment \u2014 to remove a -dev/-staging deploy target use delete_environment instead.",
     "",
     'When to use: "delete / tear down the dev environment", once you have shipped the fix and no longer need the box.',
     "",
@@ -2411,7 +2980,7 @@ defineTool({
     'Example: delete_dev_environment({ service_id: "svc_api_dev" }) \u2192 removes the dev box, its cloned database, and the /workspace volume.'
   ].join("\n"),
   input: {
-    service_id: z13.union([z13.number().int().positive(), z13.string()]).describe("The dev box to tear down \u2014 numeric id or publicId.")
+    service_id: z14.union([z14.number().int().positive(), z14.string()]).describe("The dev box to tear down \u2014 numeric id or publicId.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2430,23 +2999,27 @@ defineTool({
   name: "resize_dev_environment",
   category: "services",
   description: [
-    "Resize a dev box (or any service) to a different size tier \u2014 the supported way to give it more memory/CPU/disk headroom (e.g. when ESLint/tsc OOMs).",
+    "Resize a cloud Dev Box (or any service) to a different size tier \u2014 the supported way to give it more memory/CPU/disk headroom (e.g. when ESLint/tsc OOMs).",
     "",
-    "When to use: a dev box OOM-killed (see exitReason/recommendedSize from list_dev_environments), or you just want more headroom. This changes the SIZE TIER \u2014 unlike per-config memory/CPU overrides, which are clamped to the current tier and so cannot grow a box past it.",
+    "This resizes a cloud Dev Box, NOT a project deploy environment.",
+    "",
+    "When to use: a Dev Box OOM-killed (see exitReason/recommendedSize from list_dev_environments), or you just want more headroom. This changes the SIZE TIER \u2014 unlike per-config memory/CPU overrides, which are clamped to the current tier and so cannot grow a box past it.",
     "",
     "How it applies: the new tier's memory + CPU take effect LIVE on the running container (no recreate, no dropped shell sessions); a larger disk takes effect on the next recreate (suspend\u2192resume). Dev boxes are floored to the OOM-safe minimum size server-side.",
     "",
     "Inputs:",
     "  - service_id: the box to resize \u2014 numeric id or publicId.",
-    '  - size: target tier (e.g. "standard", "large", "xlarge").',
+    '  - size: target tier \u2014 one of the service catalog sizes (e.g. "standard", "large", "xlarge").',
     "",
     "Returns: { service } with the new plan.",
     "",
     'Example: resize_dev_environment({ service_id: "svc_skyskraber_dev", size: "large" }) \u2192 bumps the box to the large tier, applied live.'
   ].join("\n"),
   input: {
-    service_id: z13.union([z13.number().int().positive(), z13.string()]).describe("The box to resize \u2014 numeric id or publicId."),
-    size: z13.string().min(1).describe('Target size tier, e.g. "standard", "large", "xlarge".')
+    service_id: z14.union([z14.number().int().positive(), z14.string()]).describe("The box to resize \u2014 numeric id or publicId."),
+    size: z14.enum(SERVICE_PLANS).describe(
+      'Target size tier (service catalog size, e.g. "standard", "large", "xlarge").'
+    )
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2465,7 +3038,9 @@ defineTool({
   name: "list_dev_environments",
   category: "services",
   description: [
-    `List the team's dev environments (the dashboard "Development" section), each annotated with the companion services attached to it.`,
+    `List the team's cloud Dev Boxes (the dashboard "Dev Boxes" / Development section), each annotated with the companion services attached to it.`,
+    "",
+    "These are cloud Dev Boxes, NOT project deploy environments \u2014 to list a project's deploy targets (Production / Staging / Preview) use list_environments instead.",
     "",
     `When to use: "show my dev environments", before opening/tearing one down, to find a box's id.`,
     "",
@@ -2492,22 +3067,62 @@ defineTool({
     });
   }
 });
+defineTool({
+  name: "list_templates",
+  category: "services",
+  description: [
+    "List the canonical Dev Box (AI dev environment) preset so an agent can see, without guessing, what a `create_standalone_dev_environment` / `create_dev_environment` actually provisions: the container image, the persistent /workspace volume (mount + default size), the OOM-safe size floor, and the companion database options.",
+    "",
+    "When to use: before creating a Dev Box, to confirm the image, the default /workspace size, the minimum plan, or which companion engines can be attached \u2014 instead of hand-duplicating those constants.",
+    "",
+    'Returns: { templates: [{ id, name, image, volume: { name, mountPath, sizeGb }, minPlan, companions }] }. Today there is one preset ("dev-environment").',
+    "",
+    'Example: list_templates() \u2192 { templates: [{ id: "dev-environment", image: "registry.hoststack.dev/hoststack/dev-env:latest", volume: { mountPath: "/workspace", sizeGb: 10 }, minPlan: "standard", companions: ["postgres","redis","meilisearch"] }] }'
+  ].join("\n"),
+  input: {},
+  handler: async () => {
+    const templates = [
+      {
+        id: "dev-environment",
+        name: "AI Dev Environment",
+        image: DEV_ENV_IMAGE,
+        volume: {
+          name: DEV_ENV_VOLUME.name,
+          mountPath: DEV_ENV_VOLUME.mountPath,
+          sizeGb: DEV_ENV_VOLUME.sizeGb
+        },
+        /** OOM-safe plan floor — a coding agent + build needs at least this. */
+        minPlan: DEV_ENV_MIN_SIZE,
+        /** Companion engines you can attach (fresh + empty), like local `make db-up`. */
+        companions: ["postgres", "redis", "meilisearch"]
+      }
+    ];
+    return respond({
+      summary: `${templates.length} Dev Box template${templates.length === 1 ? "" : "s"} available (image ${DEV_ENV_IMAGE}, /workspace ${DEV_ENV_VOLUME.sizeGb} GB, floor "${DEV_ENV_MIN_SIZE}").`,
+      data: { templates }
+    });
+  }
+});
 defineTool({
   name: "create_standalone_dev_environment",
   category: "services",
   description: [
-    "Create a STANDALONE dev environment in one call: a cloud box (Claude Code + Codex + OpenCode + MCPs) on a persistent /workspace, from a connected GitHub repo, an arbitrary clone URL, or blank \u2014 with optional companion Postgres / Redis / Meilisearch wired into its env (mirrors a local `make db-up`). The box lives in the team's hidden Development home, NOT under a project.",
+    "Create a STANDALONE Dev Box in one call: a cloud box (Claude Code + Codex + OpenCode + MCPs) on a persistent /workspace, from a connected GitHub repo, an arbitrary clone URL, or blank \u2014 with optional companion Postgres / Redis / Meilisearch wired into its env (mirrors a local `make db-up`). The box lives in the team's hidden Development home, NOT under a project.",
+    "",
+    "This makes a cloud Dev Box, NOT a project deploy environment (create_environment \u2192 Production / Staging / Preview). It is a workspace you code in, not a deployment target.",
+    "",
+    'Every Dev Box \u2014 with or without companions \u2014 also ships NATIVE Postgres 17, Redis and Meilisearch INSIDE the box, started with `dev-services up` (postgres :5432 as user "dev" with trust auth, redis :6379, meilisearch :7700). That is the no-Docker replacement for `make db-up` and is the right answer for local development inside the box; there is no Docker daemon available in there. The `companions` option is different \u2014 it attaches SEPARATE managed databases to the box\'s environment for when the box needs a real, persistent, backed-up datastore.',
     "",
     'When to use: "create a dev environment for <repo>", "spin me up a cloud dev box with a Postgres". Distinct from spin_up_dev_environment (which clones an EXISTING service) and create_dev_environment (a bare box in a chosen project).',
     "",
     "Inputs:",
-    "  - name: the dev box name.",
+    '  - name (optional): the Dev Box name. Omit it and the box is named after its source (the repo name, or "dev-box" when blank), with a numeric suffix if that name is taken \u2014 so "give me a dev box" needs no invented name.',
     '  - source_kind: "github_repo" (clone a connected repo \u2014 needs github_repo_id), "url" (clone any http(s) git URL \u2014 needs clone_url), or "blank" (empty box).',
     "  - github_repo_id (for github_repo): numeric id of a connected GitHub repo.",
     "  - clone_url (for url): an http(s) git clone URL.",
     "  - branch (optional): branch to clone.",
     '  - databases (optional): companion services to attach \u2014 any of "postgres", "redis", "meilisearch".',
-    '  - plan (optional): box size (default "micro").',
+    '  - plan (optional): box size. Defaults to "standard" (2 GB) \u2014 the OOM-safe floor (DEV_ENV_MIN_SIZE); a smaller plan is floored up to "standard" server-side.',
     "  - agent_accounts (optional): bind specific saved agent logins by account id per provider. OMIT to auto-inherit the box owner's default logins (claude/codex/opencode), so `claude` is already authenticated on first boot \u2014 no manual login.",
     "",
     "Returns: { service, devUrl, deployId } \u2014 deploying. Once live: open the Terminal tab, run `claude`, start the dev server on $PORT, view at https://<devUrl>. Tear down with delete_dev_environment.",
@@ -2515,17 +3130,21 @@ defineTool({
     'Example: create_standalone_dev_environment({ name: "app-dev", source_kind: "github_repo", github_repo_id: 42, databases: ["postgres","redis"] })'
   ].join("\n"),
   input: {
-    name: z13.string().min(1).max(100).describe("Dev box name."),
-    source_kind: z13.enum(["github_repo", "url", "blank"]).describe("Where the code comes from."),
-    github_repo_id: z13.number().int().positive().optional().describe('Connected GitHub repo id (required when source_kind="github_repo").'),
-    clone_url: z13.string().url().optional().describe('http(s) git clone URL (required when source_kind="url").'),
-    branch: z13.string().min(1).max(255).optional().describe("Branch to clone."),
-    databases: z13.array(z13.enum(["postgres", "redis", "meilisearch"])).optional().describe("Companion services to attach (fresh + empty)."),
-    plan: z13.enum(SERVICE_PLANS).optional().describe('Box size (default "micro").'),
-    agent_accounts: z13.array(
-      z13.object({
-        provider: z13.enum(["claude", "codex", "opencode"]),
-        account_id: z13.number().int().positive()
+    name: z14.string().min(1).max(100).optional().describe(
+      'Dev Box name. Omit to have it named after the source (the repo name, or "dev-box" for a blank one), de-duplicated against existing boxes.'
+    ),
+    source_kind: z14.enum(["github_repo", "url", "blank"]).describe("Where the code comes from."),
+    github_repo_id: z14.number().int().positive().optional().describe('Connected GitHub repo id (required when source_kind="github_repo").'),
+    clone_url: z14.string().url().optional().describe('http(s) git clone URL (required when source_kind="url").'),
+    branch: z14.string().min(1).max(255).optional().describe("Branch to clone."),
+    databases: z14.array(z14.enum(["postgres", "redis", "meilisearch"])).optional().describe("Companion services to attach (fresh + empty)."),
+    plan: z14.enum(SERVICE_PLANS).optional().describe(
+      'Box size (default "standard" \u2014 2 GB; a smaller plan is floored to "standard").'
+    ),
+    agent_accounts: z14.array(
+      z14.object({
+        provider: z14.enum(["claude", "codex", "opencode"]),
+        account_id: z14.number().int().positive()
       })
     ).max(3).optional().describe(
       "Bind saved agent logins by account id per provider. Omit to inherit the box owner's default logins automatically."
@@ -2562,7 +3181,7 @@ defineTool({
       source = { kind: "blank" };
     }
     const input = {
-      name: args.name,
+      ...args.name ? { name: args.name } : {},
       source,
       ...args.databases ? { databases: args.databases } : {},
       ...args.plan ? { plan: args.plan } : {},
@@ -2595,12 +3214,12 @@ defineTool({
     "Inputs:",
     '  - service_id: publicId of the service (e.g. "svc_abc123").',
     "",
-    "Returns: { service: Service, config: ServiceConfig } \u2014 service has type/status/runtime/repoUrl/branch/autoDeploy/region/plan/timestamps; config has memoryMb, cpuShares, diskSizeGb, port, protocol, healthCheckEnabled, healthCheckInterval, healthCheckTimeout, healthCheckGracePeriodSec, restartPolicy, preDeployCommand, min/maxInstances, scale thresholds.",
+    'Returns: { service: Service, config: ServiceConfig } \u2014 service has type/status/runtime/repoUrl/branch/autoDeploy/region/plan/timestamps; config has memoryMb, cpuShares, diskSizeGb, port, protocol, healthCheckEnabled, healthCheckInterval, healthCheckTimeout, healthCheckGracePeriodSec, restartPolicy, deployStrategy ("rolling" | "recreate"), preDeployCommand, min/maxInstances, scale thresholds.',
     "",
     'Example: get_service({ service_id: "svc_abc" }) \u2192 { service: { type: "web", status: "running", \u2026 }, config: { healthCheckGracePeriodSec: 120, \u2026 } }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId (e.g. svc_abc123).")
+    service_id: z14.string().describe("Service publicId (e.g. svc_abc123).")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2632,7 +3251,7 @@ defineTool({
     'Example: get_service_metrics({ service_id: "svc_abc" }) \u2192 { metrics: { cpu: 0.42, memory: 0.71, \u2026 } }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId.")
+    service_id: z14.string().describe("Service publicId.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2661,9 +3280,9 @@ defineTool({
     'Example: get_service_metrics_history({ service_id: "svc_abc", from: "-1h" }) \u2192 60-ish points for the last hour.'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId."),
-    from: z13.string().optional().describe('ISO-8601 lower bound or relative offset (e.g. "-1h", "-2d").'),
-    to: z13.string().optional().describe("ISO-8601 upper bound; defaults to now.")
+    service_id: z14.string().describe("Service publicId."),
+    from: z14.string().optional().describe('ISO-8601 lower bound or relative offset (e.g. "-1h", "-2d").'),
+    to: z14.string().optional().describe("ISO-8601 upper bound; defaults to now.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2707,8 +3326,8 @@ defineTool({
     'Example: update_service({ service_id: "svc_abc", name: "api-prod" }) \u2192 { service: { name: "api-prod", \u2026 } }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId."),
-    name: z13.string().min(1).max(60).describe("New service name (1\u201360 chars).")
+    service_id: z14.string().describe("Service publicId."),
+    name: z14.string().min(1).max(60).describe("New service name (1\u201360 chars).")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2745,6 +3364,7 @@ defineTool({
     "  - port (optional): integer 1\u201365535 \u2014 container port the platform forwards traffic to.",
     '  - protocol (optional): "http" | "tcp".',
     '  - restart_policy (optional): "always" | "on-failure" | "no".',
+    `  - deploy_strategy (optional): "rolling" (default) | "recreate". SET THIS TO "recreate" for any single-container service that holds an exclusive lock on a mounted volume \u2014 a database running inside the container, an embedded queue, anything with a lockfile or a fixed host port on shared storage. Under the default rolling strategy those services CANNOT deploy at all: the new container can't open the datadir the outgoing container still holds, so it exits; because it never goes healthy the old one is never stopped; because the old one is never stopped the lock is never released. The deploy deadlocks for the whole grace period and then reports "Health check timed out". "recreate" stops the old container first, at the cost of a brief outage.`,
     "  - pre_deploy_command (optional): shell command run before the new release accepts traffic (typical use: migrations).",
     "  - instance_count (optional): integer 1\u201350 \u2014 pin both min and max instances to this value.",
     "  - min_instances, max_instances (optional): integers \u2014 autoscale bounds. Use instead of instance_count when you want a range.",
@@ -2756,37 +3376,40 @@ defineTool({
     'Example: update_service_config({ service_id: "svc_abc", health_check_grace_period_sec: 180 }) \u2192 { config: { healthCheckGracePeriodSec: 180, \u2026 } }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId."),
-    install_command: z13.string().nullable().optional().describe("Install shell command. Null clears."),
-    build_command: z13.string().nullable().optional().describe("Build shell command. Null clears."),
-    start_command: z13.string().nullable().optional().describe("Start shell command. Null clears."),
-    branch: z13.string().optional().describe("Git branch to track."),
-    root_directory: z13.string().optional().describe("Build context root."),
-    dockerfile_path: z13.string().nullable().optional().describe("Path to Dockerfile relative to root. Null clears."),
-    auto_deploy: z13.boolean().optional().describe("Auto-deploy on push."),
-    health_check_path: z13.string().nullable().optional().describe('HTTP health-check path (e.g. "/health"). Null = TCP-only check.'),
-    health_check_enabled: z13.boolean().optional().describe("Toggle health checking on/off."),
-    health_check_interval: z13.number().int().min(5).max(300).optional().describe("How often the check runs, in seconds (5\u2013300)."),
-    health_check_timeout: z13.number().int().min(1).max(60).optional().describe("Single-attempt timeout in seconds (1\u201360)."),
-    health_check_grace_period_sec: z13.number().int().min(1).max(1800).optional().describe(
+    service_id: z14.string().describe("Service publicId."),
+    install_command: z14.string().nullable().optional().describe("Install shell command. Null clears."),
+    build_command: z14.string().nullable().optional().describe("Build shell command. Null clears."),
+    start_command: z14.string().nullable().optional().describe("Start shell command. Null clears."),
+    branch: z14.string().optional().describe("Git branch to track."),
+    root_directory: z14.string().optional().describe("Build context root."),
+    dockerfile_path: z14.string().nullable().optional().describe("Path to Dockerfile relative to root. Null clears."),
+    auto_deploy: z14.boolean().optional().describe("Auto-deploy on push."),
+    health_check_path: z14.string().nullable().optional().describe('HTTP health-check path (e.g. "/health"). Null = TCP-only check.'),
+    health_check_enabled: z14.boolean().optional().describe("Toggle health checking on/off."),
+    health_check_interval: z14.number().int().min(5).max(300).optional().describe("How often the check runs, in seconds (5\u2013300)."),
+    health_check_timeout: z14.number().int().min(1).max(60).optional().describe("Single-attempt timeout in seconds (1\u201360)."),
+    health_check_grace_period_sec: z14.number().int().min(1).max(1800).optional().describe(
       "Startup grace period in seconds (1\u20131800). Raise this if the app needs more time to boot before health checks start counting failures."
     ),
-    memory_mb: z13.number().int().min(128).max(16384).optional().describe("Container memory cap in MB (128\u201316384)."),
-    cpu_shares: z13.number().int().min(128).max(4096).optional().describe("Relative CPU weight (128\u20134096)."),
-    disk_size_gb: z13.number().int().min(1).max(100).optional().describe("Ephemeral disk size in GB (1\u2013100)."),
-    port: z13.number().int().min(1).max(65535).optional().describe("Container port the platform forwards traffic to."),
-    protocol: z13.enum(["http", "tcp"]).optional().describe("Traffic protocol."),
-    restart_policy: z13.enum(["always", "on-failure", "no"]).optional().describe("Docker restart policy."),
-    pre_deploy_command: z13.string().optional().describe("Shell command run before the new release accepts traffic."),
-    instance_count: z13.number().int().positive().max(50).optional().describe("Pin min and max instances to this value (1\u201350)."),
-    min_instances: z13.number().int().min(0).max(50).optional().describe("Autoscale lower bound. Use with max_instances for a range."),
-    max_instances: z13.number().int().min(1).max(50).optional().describe("Autoscale upper bound. Use with min_instances for a range."),
-    scale_cpu_threshold: z13.number().int().min(10).max(100).optional().describe("Autoscale CPU trigger percentage (10\u2013100)."),
-    scale_memory_threshold: z13.number().int().min(10).max(100).optional().describe("Autoscale memory trigger percentage (10\u2013100)."),
-    log_filter_rules: z13.array(
-      z13.object({
-        pattern: z13.string().min(1).max(200),
-        action: z13.enum(["drop", "downgrade"])
+    memory_mb: z14.number().int().min(128).max(16384).optional().describe("Container memory cap in MB (128\u201316384)."),
+    cpu_shares: z14.number().int().min(128).max(4096).optional().describe("Relative CPU weight (128\u20134096)."),
+    disk_size_gb: z14.number().int().min(1).max(100).optional().describe("Ephemeral disk size in GB (1\u2013100)."),
+    port: z14.number().int().min(1).max(65535).optional().describe("Container port the platform forwards traffic to."),
+    protocol: z14.enum(["http", "tcp"]).optional().describe("Traffic protocol."),
+    restart_policy: z14.enum(["always", "on-failure", "no"]).optional().describe("Docker restart policy."),
+    deploy_strategy: z14.enum(["rolling", "recreate"]).optional().describe(
+      'How a deploy replaces the container. "rolling" (default) = start new, wait for healthy, switch traffic, stop old (zero downtime). "recreate" = stop old first, then start new (brief outage) \u2014 required for a container holding an exclusive lock on a mounted volume, which cannot deploy at all under rolling.'
+    ),
+    pre_deploy_command: z14.string().optional().describe("Shell command run before the new release accepts traffic."),
+    instance_count: z14.number().int().positive().max(50).optional().describe("Pin min and max instances to this value (1\u201350)."),
+    min_instances: z14.number().int().min(0).max(50).optional().describe("Autoscale lower bound. Use with max_instances for a range."),
+    max_instances: z14.number().int().min(1).max(50).optional().describe("Autoscale upper bound. Use with min_instances for a range."),
+    scale_cpu_threshold: z14.number().int().min(10).max(100).optional().describe("Autoscale CPU trigger percentage (10\u2013100)."),
+    scale_memory_threshold: z14.number().int().min(10).max(100).optional().describe("Autoscale memory trigger percentage (10\u2013100)."),
+    log_filter_rules: z14.array(
+      z14.object({
+        pattern: z14.string().min(1).max(200),
+        action: z14.enum(["drop", "downgrade"])
       })
     ).max(50).optional().describe(
       "Runtime-log filter rules. Empty array [] clears all rules. Each pattern is case-insensitive substring match against the message."
@@ -2821,6 +3444,8 @@ defineTool({
     if (args.port !== void 0) configUpdate["port"] = args.port;
     if (args.protocol !== void 0) configUpdate["protocol"] = args.protocol;
     if (args.restart_policy !== void 0) configUpdate["restartPolicy"] = args.restart_policy;
+    if (args.deploy_strategy !== void 0)
+      configUpdate["deployStrategy"] = args.deploy_strategy;
     if (args.pre_deploy_command !== void 0)
       configUpdate["preDeployCommand"] = args.pre_deploy_command;
     if (args.instance_count !== void 0) {
@@ -2881,7 +3506,7 @@ defineTool({
     'Example: suspend_service({ service_id: "svc_dev" }) \u2192 { ok: true }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId.")
+    service_id: z14.string().describe("Service publicId.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2905,7 +3530,7 @@ defineTool({
     'Example: resume_service({ service_id: "svc_dev" }) \u2192 { ok: true }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId.")
+    service_id: z14.string().describe("Service publicId.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2913,6 +3538,35 @@ defineTool({
     return respond({ summary: `Resumed service ${args.service_id}.`, data: { ok: true } });
   }
 });
+defineTool({
+  name: "delete_service",
+  category: "services",
+  description: [
+    "Permanently delete a service: stops and removes its containers, releases its hostname and routes, and cascade-deletes its attached volumes, env vars, domains and deploy history. Irreversible.",
+    "",
+    "When to use: the user explicitly asks to delete or remove a service, or you are cleaning up a service that was created by mistake or is no longer needed. Without this, a broken or abandoned service could only be removed from the dashboard \u2014 so a service that failed to come up had to be left in place and worked around by creating another one.",
+    "",
+    "ALWAYS confirm with the user before calling this on anything that has served traffic. To stop a service temporarily without losing it, use suspend_service instead. To tear down an agentic Dev Box (which also cascades its cloned database), use delete_dev_environment.",
+    "",
+    "Inputs:",
+    "  - service_id: publicId of the service to delete.",
+    "",
+    "Returns: { ok: true }.",
+    "",
+    'Example: delete_service({ service_id: "svc_abandoned" }) \u2192 { ok: true }'
+  ].join("\n"),
+  input: {
+    service_id: z14.string().describe("Service publicId.")
+  },
+  handler: async (args, ctx) => {
+    const teamId = await ctx.resolveTeamId();
+    await ctx.hoststack.services.delete(teamId, args.service_id);
+    return respond({
+      summary: `Deleted service ${args.service_id} and its attached resources. This cannot be undone.`,
+      data: { ok: true }
+    });
+  }
+});
 defineTool({
   name: "get_service_logs",
   category: "logs",
@@ -2939,16 +3593,16 @@ defineTool({
     '  - Just count error lines without fetching them: get_service_logs({ service_id: "svc_abc", level: "error", since: "-5m", count_only: true }) \u2192 { count: 47 }'
   ].join("\n"),
   input: {
-    service_id: z13.string().describe("Service publicId."),
-    lines: z13.number().int().positive().max(1e3).optional().describe("Tail size; default 200, hard cap 1000."),
-    since: z13.string().optional().describe('ISO-8601 timestamp or relative offset (e.g. "-5m", "-1h").'),
-    until: z13.string().optional().describe("ISO-8601 timestamp or relative offset upper bound."),
-    stream: z13.enum(["stdout", "stderr"]).optional().describe("Restrict to one stream."),
-    level: z13.enum(["stdout", "stderr", "trace", "debug", "info", "warn", "error", "fatal"]).optional().describe(
+    service_id: z14.string().describe("Service publicId."),
+    lines: z14.number().int().positive().max(1e3).optional().describe("Tail size; default 200, hard cap 1000."),
+    since: z14.string().optional().describe('ISO-8601 timestamp or relative offset (e.g. "-5m", "-1h").'),
+    until: z14.string().optional().describe("ISO-8601 timestamp or relative offset upper bound."),
+    stream: z14.enum(["stdout", "stderr"]).optional().describe("Restrict to one stream."),
+    level: z14.enum(["stdout", "stderr", "trace", "debug", "info", "warn", "error", "fatal"]).optional().describe(
       "Filter by structured JSON log level (pino/bunyan/severity). Falls back to a stream-alias hint for plain-text logs (info/debug\u2192stdout, warn/error/fatal\u2192stderr)."
     ),
-    search: z13.string().max(100).optional().describe("Case-insensitive substring filter."),
-    count_only: z13.boolean().optional().describe("When true, return only { count } \u2014 skips the log payload.")
+    search: z14.string().max(100).optional().describe("Case-insensitive substring filter."),
+    count_only: z14.boolean().optional().describe("When true, return only { count } \u2014 skips the log payload.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -2997,14 +3651,14 @@ defineTool({
     'Example: get_service_logs_bulk({ service_ids: ["svc_api", "svc_worker"], level: "error", since: "-15m", count_only: true }) \u2192 { results: { svc_api: { count: 0 }, svc_worker: { count: 12 } } }.'
   ].join("\n"),
   input: {
-    service_ids: z13.array(z13.string()).min(1).max(10).describe("Service publicIds (1\u201310). Hard cap 10 to bound parallel work."),
-    lines_per_service: z13.number().int().positive().max(500).optional().describe("Tail size per service; default 100, hard cap 500."),
-    since: z13.string().optional().describe('ISO-8601 timestamp or relative offset (e.g. "-5m", "-1h").'),
-    until: z13.string().optional().describe("ISO-8601 timestamp or relative offset upper bound."),
-    stream: z13.enum(["stdout", "stderr"]).optional().describe("Restrict to one stream."),
-    level: z13.enum(["stdout", "stderr", "trace", "debug", "info", "warn", "error", "fatal"]).optional().describe("Structured log level filter (same as get_service_logs)."),
-    search: z13.string().max(100).optional().describe("Case-insensitive substring filter."),
-    count_only: z13.boolean().optional().describe("When true, return only counts per service \u2014 skips the log payload.")
+    service_ids: z14.array(z14.string()).min(1).max(10).describe("Service publicIds (1\u201310). Hard cap 10 to bound parallel work."),
+    lines_per_service: z14.number().int().positive().max(500).optional().describe("Tail size per service; default 100, hard cap 500."),
+    since: z14.string().optional().describe('ISO-8601 timestamp or relative offset (e.g. "-5m", "-1h").'),
+    until: z14.string().optional().describe("ISO-8601 timestamp or relative offset upper bound."),
+    stream: z14.enum(["stdout", "stderr"]).optional().describe("Restrict to one stream."),
+    level: z14.enum(["stdout", "stderr", "trace", "debug", "info", "warn", "error", "fatal"]).optional().describe("Structured log level filter (same as get_service_logs)."),
+    search: z14.string().max(100).optional().describe("Case-insensitive substring filter."),
+    count_only: z14.boolean().optional().describe("When true, return only counts per service \u2014 skips the log payload.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -3050,7 +3704,8 @@ defineTool({
 });
 
 // src/tools/volumes.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
+var MIN_VOLUME_SIZE_GB = 10;
 defineTool({
   name: "list_volumes",
   category: "volumes",
@@ -3067,7 +3722,7 @@ defineTool({
     'Example: list_volumes({ service_id: "svc_abc" }) \u2192 { items: [{ name: "data", mountPath: "/var/data", sizeGb: 10, status: "active" }] }'
   ].join("\n"),
   input: {
-    service_id: z14.string().describe("Service publicId (e.g. svc_abc123).")
+    service_id: z15.string().describe("Service publicId (e.g. svc_abc123).")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -3089,17 +3744,24 @@ defineTool({
     "  - service_id: publicId of the service to attach to.",
     "  - name: lowercase alphanumeric + hyphens, \u226464 chars (used as the docker volume identifier \u2014 change with care once data is written).",
     '  - mount_path: in-container absolute path (e.g. "/var/data").',
-    "  - size_gb: optional, 1\u2013100, default 1. Counts against your plan storage quota and is metered for billing.",
+    "  - size_gb: optional, 10\u2013100, default 10. 10 GB is the platform minimum (the underlying block storage cannot provision anything smaller) \u2014 a smaller value is rejected here rather than failing the next deploy. Metered for billing.",
     "",
-    "Returns: { volume: Volume } \u2014 the created record.",
+    'Returns: { volume: Volume } \u2014 the created record. A durable volume comes back `status: "pending"`; the disk is created and attached on the next deploy, which flips it to "active". A deploy is required before the mount exists.',
     "",
-    'Example: create_volume({ service_id: "svc_abc", name: "data", mount_path: "/var/data", size_gb: 10 }) \u2192 { volume: { name: "data", mountPath: "/var/data", sizeGb: 10, status: "active" } }'
+    'Example: create_volume({ service_id: "svc_abc", name: "data", mount_path: "/var/data", size_gb: 10 }) \u2192 { volume: { name: "data", mountPath: "/var/data", sizeGb: 10, status: "pending" } }'
   ].join("\n"),
   input: {
-    service_id: z14.string().describe("Service publicId."),
-    name: z14.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe("Volume name (lowercase alphanumeric + hyphens)."),
-    mount_path: z14.string().startsWith("/").max(500).describe("In-container mount path (absolute)."),
-    size_gb: z14.number().int().min(1).max(100).optional().describe("Disk size in GB (default 1, max 100).")
+    service_id: z15.string().describe("Service publicId."),
+    name: z15.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe("Volume name (lowercase alphanumeric + hyphens)."),
+    mount_path: z15.string().startsWith("/").max(500).describe("In-container mount path (absolute)."),
+    // 10 GB is the real floor: the block-storage backend rejects anything
+    // smaller. Advertising 1 GB here (and defaulting to it) meant taking the
+    // defaults produced a volume that provisioned with `Hetzner API error:
+    // 422` on the NEXT deploy, with nothing tying the failure back to the
+    // size. Reject it at the call instead.
+    size_gb: z15.number().int().min(MIN_VOLUME_SIZE_GB).max(100).optional().describe(
+      `Disk size in GB (minimum ${MIN_VOLUME_SIZE_GB}, default ${MIN_VOLUME_SIZE_GB}, max 100 via MCP).`
+    )
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -3111,7 +3773,7 @@ defineTool({
     const response = await ctx.hoststack.volumes.create(teamId, args.service_id, input);
     const data = { volume: shape(response.volume) };
     return respond({
-      summary: `Attached volume "${args.name}" (${args.size_gb ?? 1}GB) at ${args.mount_path} on service ${args.service_id}.`,
+      summary: `Attached volume "${args.name}" (${response.volume.sizeGb}GB) at ${args.mount_path} on service ${args.service_id}. Status is "${response.volume.status}" \u2014 deploy the service to provision and mount it.`,
       data
     });
   }
@@ -3135,10 +3797,10 @@ defineTool({
     'Example: update_volume({ service_id: "svc_abc", volume_id: "vol_xyz", size_gb: 20 }) \u2192 { volume: { sizeGb: 20, \u2026 } }'
   ].join("\n"),
   input: {
-    service_id: z14.string().describe("Service publicId."),
-    volume_id: z14.string().describe("Volume publicId (e.g. vol_\u2026)."),
-    mount_path: z14.string().startsWith("/").max(500).optional().describe("New mount path."),
-    size_gb: z14.number().int().min(1).max(100).optional().describe("New size in GB.")
+    service_id: z15.string().describe("Service publicId."),
+    volume_id: z15.string().describe("Volume publicId (e.g. vol_\u2026)."),
+    mount_path: z15.string().startsWith("/").max(500).optional().describe("New mount path."),
+    size_gb: z15.number().int().min(MIN_VOLUME_SIZE_GB).max(100).optional().describe(`New size in GB (minimum ${MIN_VOLUME_SIZE_GB}, grow-only).`)
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -3176,8 +3838,8 @@ defineTool({
     'Example: delete_volume({ service_id: "svc_abc", volume_id: "vol_xyz" }) \u2192 { ok: true }'
   ].join("\n"),
   input: {
-    service_id: z14.string().describe("Service publicId."),
-    volume_id: z14.string().describe("Volume publicId.")
+    service_id: z15.string().describe("Service publicId."),
+    volume_id: z15.string().describe("Volume publicId.")
   },
   handler: async (args, ctx) => {
     const teamId = await ctx.resolveTeamId();
@@ -3191,7 +3853,7 @@ defineTool({
 
 // src/server-factory.ts
 var PACKAGE_NAME = "hoststack";
-var PACKAGE_VERSION = "0.9.1";
+var PACKAGE_VERSION = MCP_VERSION;
 function createMcpServer(options) {
   const baseUrl = (options.baseUrl ?? "https://hoststack.dev").replace(/\/$/, "");
   const hoststack = new HostStack({ apiKey: options.apiKey, baseUrl });