@offlocal/mcp 0.3.5 → 0.3.6

package/README.md

@@ -57,9 +57,33 @@ Paste this into a fresh agent chat:
 | Tool | What it does |
 | --- | --- |
 | `offlocal_ping` | Verify the agent is connected. Returns your email if so. |
+| `offlocal_plan` | Inspect a project, identify required resources, and guide the agent through intent-driven platform choices. |
 | `offlocal_deploy` | Detect runtime, zip the source, upload, kick off the build + deploy pipeline. Returns a `deploymentId`. |
 | `offlocal_status` | Poll a deployment. Returns the current phase, ETA, and the live URL on success. |
 | `offlocal_logs` | Read the most recent container logs from CloudWatch. |
+| `offlocal_resolve_requirement` | Compare Offlocal-managed resources, Offlocal connectors, and existing env values. |
+| `offlocal_connect` | Link the user's provider account to Offlocal through OAuth. |
+| `offlocal_provision` | Preview and provision resources through an Offlocal-connected provider. |
+
+## Agent behavior
+
+The MCP supplies tools, structured plans, and instructions to the host AI agent;
+it does not generate the conversation itself.
+
+- Offlocal-managed resources run on Offlocal infrastructure.
+- Offlocal connectors link the user's provider account to Offlocal. Offlocal
+  orchestrates through the connection; the provider hosts the resources and may
+  bill the user.
+- Clear user intent covers the matching workflow. Requests such as "use
+  Railway", "go ahead", or "use whatever is fastest" should not trigger repeated
+  confirmation questions.
+- If infrastructure intent is missing, the agent asks only for the unresolved
+  choice.
+- Provision previews remain visible for scope and cost transparency. The agent
+  continues automatically when the preview matches established intent, and
+  pauses only for a material scope or cost change.
+- Saved preferences influence future deployment plans but are only written when
+  the user expresses an ongoing preference.
 
 ## Env
 

package/dist/index.js

@@ -31,19 +31,19 @@ async function main() {
         version: MCP_VERSION,
     });
     server.tool("offlocal_ping", "Verify the Offlocal connection. Returns the signed-in email if connected, or an error message if not. This tool does NOT deploy anything, upload anything, or provision any resources - it is the right tool to call when the user asks to 'check my Offlocal connection' or similar.", PingInputShape, async (args) => pingHandler(PingSchema.parse(args)));
-    server.tool("offlocal_plan", "START HERE when the user asks to deploy/ship/set up a project. Detects the app + the resources it needs (e.g. a Postgres database), applies the user's saved platform preferences, and returns a complete proposed plan (which platform for each piece — Offlocal.ai by default, or Supabase/PlanetScale/DigitalOcean/Railway). Present the plan to the user verbatim and let them confirm with 'go' or switch any line. Then execute the steps the plan lists. Do NOT deploy or provision anything until the user confirms the plan.", PlanInputShape, async (args) => planHandler(PlanSchema.parse(args)));
-    server.tool("offlocal_set_preference", "Remember the user's platform choice for a capability (e.g. capability:'postgres', platform:'supabase'), so future plans default to it. Call this when the user says 'use X for Y', then re-run offlocal_plan.", SetPreferenceInputShape, async (args) => setPreferenceHandler(SetPreferenceSchema.parse(args)));
+    server.tool("offlocal_plan", "START HERE for deployment/setup requests. Detects the project, required resources, saved preferences, eligible platforms, and unresolved choices. Follow the authorization and recommendation guidance returned with the plan.", PlanInputShape, async (args) => planHandler(PlanSchema.parse(args)));
+    server.tool("offlocal_set_preference", "Remember an explicit platform preference for future plans. Use only when the plan guidance and conversation indicate the choice should persist.", SetPreferenceInputShape, async (args) => setPreferenceHandler(SetPreferenceSchema.parse(args)));
     server.tool("offlocal_deploy", "Deploy an app from a local directory to Offlocal. Returns a deploymentId you can poll with offlocal_status. Supports Node, Python, Go, Rust, and static sites out of the box (auto-detecting runtime/framework/port), and uses the project's own Dockerfile as-is when one exists. For an unrecognized stack with no Dockerfile, it returns instructions asking you to add a Dockerfile and re-run - follow them, then call this again. You can override appName and port. Only call this when the user explicitly asks to deploy.", DeployInputShape, async (args) => deployHandler(DeploySchema.parse(args)));
     server.tool("offlocal_status", "Get the current status of a deployment. Poll this every few seconds after offlocal_deploy until status is 'live' or 'failed'.", StatusInputShape, async (args) => statusHandler(StatusSchema.parse(args)));
     server.tool("offlocal_logs", "Read recent container logs for a deployment. Useful for debugging a failed deploy or watching live output.", LogsInputShape, async (args) => logsHandler(LogsSchema.parse(args)));
     server.tool("offlocal_rollback", "Roll a project back to a previous build. Re-deploys an existing image (skips the build, ~1 min), so it's fast and safe. Defaults to the most recent prior build; pass toDeploymentId to target a specific one. Use when a new deploy is broken or the user wants the last working version back.", RollbackInputShape, async (args) => rollbackHandler(RollbackSchema.parse(args)));
     server.tool("offlocal_plans", "Show the user's current Offlocal.ai plan, the full tier catalog (prices, limits, features), and upcoming features. Use it to answer plan and pricing questions, and to show upgrade options when the user needs more capacity (projects, databases, custom domains). Includes the billing link.", PlansInputShape, async () => plansHandler());
-    server.tool("offlocal_resolve_requirement", "When a deploy needs an external resource (a database, hosting, etc.) that the project doesn't already have, call this with the capability (e.g. 'postgres') to get the providers that can supply it and their connection status. Present the options to the user and let them choose; the user can also just paste an existing connection string as an env var instead.", ResolveRequirementInputShape, async (args) => resolveRequirementHandler(ResolveRequirementSchema.parse(args)));
-    server.tool("offlocal_connect", "Get a browser link for the user to connect a chosen provider via OAuth. You CANNOT complete OAuth yourself - share the link, then poll offlocal_list_connections until the provider is 'connected'. Only call this if the user chose a provider that isn't connected yet.", ConnectInputShape, async (args) => connectHandler(ConnectSchema.parse(args)));
-    server.tool("offlocal_list_connections", "List the user's provider connections and their status. Use this to poll after offlocal_connect (no faster than every 5 seconds) until a provider becomes 'connected'.", ListConnectionsInputShape, async () => listConnectionsHandler());
-    server.tool("offlocal_provision", "Provision a real resource (e.g. a database) on a CONNECTED provider. ALWAYS call first with confirm omitted/false to get a PREVIEW + cost, show the user, and get explicit confirmation — then call again with confirm:true. Pass projectId (from offlocal_deploy) so the resulting DATABASE_URL is auto-injected. May return status 'provisioning' for DigitalOcean/Railway — poll with offlocal_provision_status.", ProvisionInputShape, async (args) => provisionHandler(ProvisionSchema.parse(args)));
+    server.tool("offlocal_resolve_requirement", "Resolve an unsettled resource requirement into eligible Offlocal-managed, Offlocal-connected, and existing-env options.", ResolveRequirementInputShape, async (args) => resolveRequirementHandler(ResolveRequirementSchema.parse(args)));
+    server.tool("offlocal_connect", "Get an Offlocal OAuth link for a provider selected by the user or plan. Share the link because the user must complete OAuth, then poll the connection status and continue the active workflow.", ConnectInputShape, async (args) => connectHandler(ConnectSchema.parse(args)));
+    server.tool("offlocal_list_connections", "List provider accounts connected to Offlocal and their status. These Offlocal connectors let Offlocal provision/manage resources through the user's provider account; the provider still hosts and may bill for those resources. Use this to inspect choices or poll after offlocal_connect no faster than every 5 seconds.", ListConnectionsInputShape, async () => listConnectionsHandler());
+    server.tool("offlocal_provision", "Preview and provision a resource through an Offlocal-connected provider. Call with confirm omitted/false first, then follow the returned preview guidance. Pass projectId so generated env vars are auto-injected.", ProvisionInputShape, async (args) => provisionHandler(ProvisionSchema.parse(args)));
     server.tool("offlocal_provision_status", "Poll an in-progress provision (DigitalOcean/Railway) by its actionId until it's ready. Poll no faster than once every ~20 seconds.", ProvisionStatusInputShape, async (args) => provisionStatusHandler(ProvisionStatusSchema.parse(args)));
-    server.tool("offlocal_create_managed_database", "Create an Offlocal Managed Postgres database for a project (the 'Offlocal' platform option for postgres). Pass the projectId from offlocal_deploy. DATABASE_URL is wired into the project automatically; redeploy to apply. Included on every plan — Free gets 1 starter database (512 MB), paid plans get more/larger.", CreateManagedDatabaseInputShape, async (args) => createManagedDatabaseHandler(CreateManagedDatabaseSchema.parse(args)));
+    server.tool("offlocal_create_managed_database", "Create Offlocal Managed Postgres for a project when selected by the user or the authenticated plan guidance. DATABASE_URL is wired automatically.", CreateManagedDatabaseInputShape, async (args) => createManagedDatabaseHandler(CreateManagedDatabaseSchema.parse(args)));
     server.tool("offlocal_set_env", "Set environment variables on a project (stored encrypted, injected on the next deploy). Use this for cross-app wiring in a monorepo — e.g. set NEXT_PUBLIC_API_URL on the web project to the API project's live URL so the frontend can reach the backend. Build-time vars (NEXT_PUBLIC_*, VITE_*) require a fresh deploy to take effect.", SetEnvInputShape, async (args) => setEnvHandler(SetEnvSchema.parse(args)));
     process.on("uncaughtException", (err) => {
         console.error("offlocal-mcp uncaught exception (continuing):", err);

package/dist/tools/plan.js

@@ -11,13 +11,25 @@ export const PlanInputShape = {
 };
 export async function planHandler(input) {
     const snapshot = await gatherPlanSnapshot(input.sourceDir);
-    const { multi, components, requirements, items, links, dbTarget } = await planProject(snapshot);
+    const { multi, components, requirements, items, links, dbTarget, agentGuidance, } = await planProject(snapshot);
     const planLines = items.map((it, i) => {
-        const emoji = it.isOfflocal ? ICON.offlocal : it.recommended ? ICON.connected : ICON.open;
+        const emoji = it.isOfflocal
+            ? ICON.offlocal
+            : it.recommended
+                ? ICON.connected
+                : ICON.open;
         const connect = it.needsConnect ? `  ${ICON.warn} first-time connect (~30s)` : "";
         const saved = it.fromPreference ? " _(your saved choice)_" : "";
+        const suggestion = it.requiresChoice && it.recommended
+            ? " _(suggested path; use automatically only if the user delegated the choice)_"
+            : "";
         const note = it.note ? `  ${ICON.soon} _${it.note}_` : "";
-        return `  ${i + 1}. ${emoji} ${it.label} → **${it.recommendedLabel}**${saved}${connect}  ·  _${it.cost}_${note}`;
+        const alternatives = it.requiresChoice
+            ? `\n     Options: ${it.options
+                .map((o) => `${o.label} (${o.managed ? "Offlocal-managed" : "Offlocal connector"}; ${o.status}; ${o.cost})`)
+                .join(" · ")} · existing env value`
+            : "";
+        return `  ${i + 1}. ${emoji} ${it.label} → **${it.recommendedLabel}**${saved}${suggestion}${connect}  ·  _${it.cost}_${note}${alternatives}`;
     });
     const wiringBlock = links.length
         ? `\n**Wiring** _(automatic)_\n` +
@@ -38,25 +50,27 @@ export async function planHandler(input) {
     const hasDatastore = requirements.some((r) => r.capability === "postgres" || r.capability === "mysql");
     const hasServerComponent = components.some((c) => c.role !== "web");
     const noteEphemeral = !hasDatastore && hasServerComponent;
-    const show = `${ICON.search} **Offlocal.ai — deployment plan**\n\n` +
+    const show = `${ICON.search} **Offlocal — deployment plan**\n\n` +
         `**Detected:** ${detectedLine}\n\n` +
         `**Plan**\n${planLines.join("\n")}\n` +
         wiringBlock +
         `\n**Setup checklist**  ${progressBar(0, checklist.length)}\n${checklistLines.join("\n")}\n\n` +
-        `Reply **"go"** to ship it ${ICON.rocket} — or switch any line ` +
-        `(e.g. _"use Supabase for the database"_, _"host the API on Railway"_).`;
+        `Offlocal is the control plane for both paths. Offlocal-managed resources run on ` +
+        `Offlocal infrastructure; Offlocal-connected providers run in the user's linked provider ` +
+        `account and may be billed by that provider.`;
     const persistenceCheck = noteEphemeral
         ? `\n\nNote: this host's storage is ephemeral. Mention data persistence only if the user asks about keeping data between deploys — a database covers it.`
         : "";
-    const agentNote = `When the user switches a line, call \`offlocal_set_preference\` ` +
-        `(capability \`${multi ? "hosting:<component> or postgres/…" : "hosting/postgres/…"}\`) then re-run \`offlocal_plan\`.` +
+    const agentNote = `${agentGuidance.authorization} ${agentGuidance.delegatedChoice} ` +
+        `${agentGuidance.unresolvedChoice} ${agentGuidance.preference}` +
         persistenceCheck +
-        `\n\n**Execution order once they confirm — walk the checklist top to bottom, ` +
+        `\n\n**Execution order once intent covers the listed actions — walk the checklist top to bottom, ` +
         `re-showing it with ${ICON.done} on finished steps so they see live progress:**\n` +
         executionSteps(items, links, dbTarget, input.sourceDir).join("\n");
     return ui({
         show,
-        next: `Show the plan above to the user and wait for "go" (or an edit). Do NOT deploy or provision anything yet.`,
+        next: `Use the user's existing request to decide the next action. Execute immediately when intent ` +
+            `covers the plan; otherwise ask only for unresolved infrastructure choices.`,
         agentNote,
         structured: {
             multiComponent: multi,
@@ -66,6 +80,7 @@ export async function planHandler(input) {
             links,
             checklist,
             dbTargetComponent: dbTarget,
+            agentGuidance,
         },
     });
 }
@@ -91,7 +106,11 @@ function buildChecklist(items, links, dbTarget) {
         out.push({
             n,
             kind: "resource",
-            text: `Provision ${it.label} → ${it.recommendedLabel}${connect}`,
+            text: it.requiresChoice
+                ? `Resolve ${it.label} platform choice${it.recommended
+                    ? ` (integrated suggestion: ${it.recommendedLabel})`
+                    : ""}`
+                : `Provision ${it.label} → ${it.recommendedLabel}${connect}`,
         });
     }
     for (const l of links) {
@@ -131,19 +150,22 @@ function executionSteps(items, links, dbTarget, sourceDir) {
             lines.push(`• ${ICON.rocket} Deploy ${labelShort(it)}: \`offlocal_deploy({ sourceDir: "${absPath(sourceDir, it.componentRelPath)}" })\` → poll \`offlocal_status\` until live → note the **projectId** and **live URL**.`);
         }
         else if (it.recommended) {
-            lines.push(`• ${ICON.web} Host ${labelShort(it)} on ${it.recommendedLabel}: ${it.cost === "coming soon" ? `${it.recommendedLabel} support is coming soon.` : `if not connected, \`offlocal_connect\` → share link → poll \`offlocal_list_connections\`. (External hosting is provider-driven.)`}`);
+            lines.push(`• ${ICON.web} Host ${labelShort(it)} on ${it.recommendedLabel}: ${it.cost === "coming soon" ? `${it.recommendedLabel} support is coming soon.` : `if not connected, \`offlocal_connect\` → share the Offlocal OAuth link → poll \`offlocal_list_connections\`, then continue the requested workflow. The connected provider hosts the resource and may bill the user.`}`);
         }
     }
     for (const it of resources) {
         if (it.isOfflocal) {
             lines.push(`• ${ICON.db} ${it.label} (Offlocal Managed Postgres): \`offlocal_create_managed_database({ projectId: <${projName(dbTarget)} projectId> })\`. DATABASE_URL is wired in automatically.`);
         }
-        else {
+        else if (it.recommended) {
             lines.push(`• ${ICON.db} ${it.label} on ${it.recommendedLabel}: ` +
                 (it.needsConnect
                     ? `\`offlocal_connect\` → share link → poll \`offlocal_list_connections\` until connected, then `
                     : "") +
-                `\`offlocal_provision({ provider: "${it.recommended}", type: "database" })\` for a PREVIEW + cost → confirm with the user → call again with \`confirm: true, projectId: <${projName(dbTarget)} projectId>\`. If it returns status **"provisioning"**, poll \`offlocal_provision_status({ actionId })\` until ready.`);
+                `\`offlocal_provision({ provider: "${it.recommended}", type: "database" })\` for a visible PREVIEW + cost. If established intent covers it and there is no material surprise, continue with \`confirm: true, projectId: <${projName(dbTarget)} projectId>\` without asking again. If it returns status **"provisioning"**, poll \`offlocal_provision_status({ actionId })\` until ready.`);
+        }
+        else {
+            lines.push(`• ${ICON.db} ${it.label}: no provisionable platform is currently available. Ask for an existing connection value and store it with \`offlocal_set_env\`.`);
         }
     }
     for (const l of links) {

package/dist/tools/providers.js

@@ -26,7 +26,9 @@ export async function listConnectionsHandler() {
         content: [
             {
                 type: "text",
-                text: `${ICON.plug} **Provider connections**\n${lines.join("\n")}`,
+                text: `${ICON.plug} **Offlocal connectors**\n` +
+                    `_These are provider accounts linked to Offlocal. Offlocal orchestrates through the connection; ` +
+                    `the provider hosts the resources and may bill the user._\n${lines.join("\n")}`,
             },
         ],
         structuredContent: { providers },
@@ -51,7 +53,7 @@ export async function resolveRequirementHandler(input) {
             structuredContent: { need, options, pasteEnvVar },
         };
     }
-    const lines = options.map((o) => {
+    const optionLine = (o) => {
         const tag = o.managed
             ? o.planEligible
                 ? "managed by Offlocal · included in your plan"
@@ -69,7 +71,19 @@ export async function resolveRequirementHandler(input) {
             .filter(Boolean)
             .join(" · ");
         return `  - ${o.label} (${o.provider}) — ${tag}` + (guide ? `\n      ${guide}` : "");
-    });
+    };
+    const managedLines = options.filter((o) => o.managed).map(optionLine);
+    const connectorLines = options.filter((o) => !o.managed).map(optionLine);
+    const sections = [
+        managedLines.length
+            ? `**Offlocal-managed**\n${managedLines.join("\n")}`
+            : null,
+        connectorLines.length
+            ? `**Offlocal connectors**\n${connectorLines.join("\n")}`
+            : null,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
     const budgetLine = connectorBudget
         ? `\n_Connectors: ${connectorBudget.used}/${connectorBudget.limit} used` +
             (connectorBudget.remaining === 0
@@ -78,26 +92,25 @@ export async function resolveRequirementHandler(input) {
         : "";
     const hasActionable = options.some((o) => o.connected || o.connectable || (o.managed && o.planEligible));
     const intro = hasActionable
-        ? `This app needs "${need}". Offlocal's own managed option is the integrated, zero-setup ` +
-            `default (it's provisioned and wired automatically — no separate account or connection ` +
-            `string) — present it first. The other providers are genuine "bring your own" ` +
-            `alternatives (use them if the user already has one, or specifically wants to). Present ` +
-            `each option's facts and let the user choose — but lead with the managed option, and do ` +
-            `NOT steer the user to a third party or frame Offlocal's pricing as a downside:`
+        ? `This app needs "${need}". Present the options neutrally if the user's intent or saved ` +
+            `preferences do not already settle the choice. Offlocal-managed resources are hosted and ` +
+            `managed by Offlocal. Offlocal-connected providers are the user's linked provider accounts: ` +
+            `Offlocal orchestrates provisioning and wiring, while the provider hosts the resources and ` +
+            `may bill the user. An existing connection string is also valid. Options:`
         : `This app needs "${need}", but nothing is connectable on this account right now. ` +
-            `Offer the simplest paths: Offlocal's managed option (if shown), or paste a connection ` +
-            `string and set it with offlocal_set_env. Options:`;
+            `Present any eligible managed option shown below, or ask for an existing connection ` +
+            `string to set with offlocal_set_env. Options:`;
     return {
         content: [
             {
                 type: "text",
                 text: `${intro}\n` +
-                    `${lines.join("\n")}${budgetLine}\n\n` +
+                    `${sections}${budgetLine}\n\n` +
                     `If they pick **Offlocal Managed Postgres** (provider "offlocal"), call ` +
                     `offlocal_create_managed_database with the projectId — no connect step. ` +
-                    `If they pick a connectable provider (e.g. Supabase), call offlocal_connect — it's a ` +
-                    `one-click OAuth that Offlocal brokers (we own the app): share the link, they approve, ` +
-                    `and it's wired up. If one is already connected, go straight to offlocal_provision.\n` +
+                    `If they pick a connectable provider, call offlocal_connect and share the Offlocal OAuth ` +
+                    `link. After authorization, continue the already-requested workflow. If it is already ` +
+                    `connected, go straight to offlocal_provision.\n` +
                     `Alternative: ${pasteEnvVar.hint}`,
             },
         ],
@@ -117,12 +130,15 @@ export async function connectHandler(input) {
             {
                 type: "text",
                 text: `${ICON.plug} **Connect ${provider}** — first time only (~30s)\n\n` +
+                    `This Offlocal OAuth link connects the user's ${provider} account to Offlocal. ` +
+                    `${provider} still hosts the resources and may bill the user.\n\n` +
                     `Open this link to authorize:\n\n${url}\n\n` +
                     `You'll be redirected back when it's done.\n\n` +
                     `———\n` +
                     `${ICON.arrow} **Next (you, the agent):** share the link above, then wait. Poll ` +
                     `\`offlocal_list_connections\` no faster than every 5s. When **${provider}** shows ` +
-                    `${ICON.connected} connected, continue to \`offlocal_provision\`. You cannot ` +
+                    `${ICON.connected} connected, continue the workflow the user already requested; do not ` +
+                    `ask for the same approval again. You cannot ` +
                     `complete the OAuth yourself.`,
             },
         ],
@@ -133,14 +149,14 @@ export const ProvisionInputShape = {
     provider: z
         .string()
         .min(1)
-        .describe("The CONNECTED external provider to provision on: supabase, planetscale, digitalocean, or railway. For Offlocal's own managed Postgres, use offlocal_create_managed_database instead — not this."),
+        .describe("The Offlocal-connected provider to provision through: supabase, planetscale, digitalocean, or railway. The provider hosts the resource and may bill the user. For Offlocal Managed Postgres, use offlocal_create_managed_database."),
     type: z
         .enum(["project", "database", "deployment", "env_vars", "branch"])
         .describe("The kind of resource to create."),
     confirm: z
         .boolean()
         .optional()
-        .describe("Leave false/omitted to get a PREVIEW + cost (no charge). Set true ONLY after the user explicitly confirmed the cost — this creates a real, billable resource."),
+        .describe("Leave false/omitted for a no-charge PREVIEW + current cost. Set true when the user's established intent covers this provider/resource and the preview has no material surprise. Ask again only for a material scope or cost change."),
     projectId: z
         .string()
         .optional()
@@ -156,7 +172,7 @@ export async function provisionHandler(input) {
     const { provider, confirm, projectId, ...spec } = input;
     if (["offlocal", "offlocal.ai"].includes(provider.toLowerCase())) {
         return text(`${ICON.warn} "offlocal" isn't a provision provider. For an Offlocal Managed Postgres database, call ` +
-            `\`offlocal_create_managed_database({ projectId })\`. \`offlocal_provision\` is only for connected external ` +
+            `\`offlocal_create_managed_database({ projectId })\`. \`offlocal_provision\` is only for Offlocal-connected ` +
             `providers: **supabase, planetscale, digitalocean, railway**.`);
     }
     const res = await provisionResource(provider, spec, {
@@ -173,9 +189,8 @@ export async function provisionHandler(input) {
         const cost = result.cost ? `\n${ICON.spark} **Cost:** ${result.cost.note}` : "";
         return text(`${ICON.warn} **PREVIEW — nothing created yet, no charge.**\n${result.preview.summary}${cost}\n\n` +
             `———\n` +
-            `${ICON.arrow} **Next (you, the agent):** show the user exactly what this creates AND the cost, ` +
-            `and get explicit confirmation. Only then call \`offlocal_provision\` again with ` +
-            `\`confirm: true\` and \`projectId\` (to auto-inject the DATABASE_URL).`, res);
+            `${ICON.arrow} **Next (you, the agent):** ${res.agentGuidance ??
+                "State the preview and follow the active plan's authorization guidance."}`, res);
     }
     if (result.status === "provisioning") {
         return text(`${ICON.busy} **Provisioning on ${provider}** (a few minutes).\n\n` +
@@ -247,5 +262,6 @@ export async function createManagedDatabaseHandler(input) {
         return text(`${ICON.fail} Couldn't create the managed database: ${res.message ?? res.error}.${planHint}`, res);
     }
     return text(`${ICON.db} **Offlocal Managed Postgres created** (${res.database?.status}). ` +
-        `${ICON.spark} DATABASE_URL is wired into this project automatically — **redeploy** to apply.`, res);
+        `${ICON.spark} DATABASE_URL is wired into this project automatically. Continue the ` +
+        `user's requested workflow with the required redeploy.`, res);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offlocal/mcp",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "MCP server for Offlocal - lets your AI coding agent deploy apps via offlocal_deploy, offlocal_status, offlocal_logs, offlocal_ping.",
   "keywords": [
     "mcp",