@nullplatform/mcp 0.1.14 → 0.1.15

package/dist/tools/create-app.js

@@ -41,10 +41,11 @@ async function buildFormReply(context, prefill) {
     // of the global set. Fetch only once a namespace is pinned (the widget refetches per namespace on
     // change); the org-level NRN returns a misleading near-empty subset.
     const templates = picked ? await listTemplates(context.np, picked.nrn).catch(() => []) : [];
-    // Same generic rule as the namespace: resolve the model's stack hint (`template`) — or an explicit
+    // Same generic rule as the namespace: resolve the MODEL's stack hint (`template`) — or an explicit
     // template_id — against THIS namespace's templates, matching on name + tags, and pin the only one.
-    // Leave it null when it's a real unhinted choice; never silently scaffold the first stack in the list
-    // (a wrong stack is worse than a deliberate pick).
+    // Inference is the model's job (it holds the context); the tool only resolves the hint it passes —
+    // no keyword guessing here. Leave it null on a genuine unhinted/ambiguous choice (a wrong stack is
+    // worse than a deliberate pick).
     const templateId = resolveChoice(templates, { id: prefill.template_id, text: prefill.template }, { pinOnly: true, haystack: (template) => `${template.name} ${(template.tags ?? []).join(" ")}` })?.id ?? null;
     const namespaces = skeleton.namespaces.map((namespace) => ({
         id: namespace.id,
@@ -56,6 +57,9 @@ async function buildFormReply(context, prefill) {
         namespaces: namespaces.map((namespace) => namespace.name).join(", ") || "—",
     }), {
         mode: "form",
+        // Model-facing note (not rendered to the user): the form is already open with every template
+        // loaded in its dropdown, so the model must NOT re-call to "pre-select" a template it just saw.
+        note: "This create FORM is now OPEN with all of this namespace's templates loaded in its Template dropdown. Do NOT call application_create again to pre-select a template or refine the namespace you just learned about — re-opening renders a DUPLICATE form panel for the same app (the mistake to avoid). To steer the choice: either name the recommended template in your text reply for the user to pick in this form's dropdown, OR (better, next time) pass a `template` stack hint on the FIRST call so it pre-selects in one render. The user picks/confirms in THIS form.",
         namespaces,
         templates: templates.map((template) => ({
             id: template.id,
@@ -72,10 +76,109 @@ async function buildFormReply(context, prefill) {
         },
     });
 }
+/**
+ * Resolve where a new app lives — the (account, namespace) pair — from the create args. Mirrors
+ * requireApp's shape: returns the pinned namespace, or an `out` reply — a `fail` when a named
+ * account/namespace matches nothing, or the create FORM when it's a real choice that needs the
+ * picker rather than a dead-end ask. Narrows to the named account first (a namespace name can
+ * repeat across accounts), then matches by id/name and auto-picks the sole candidate.
+ */
+async function resolveCreateNamespace(context, args, name, repoUrl) {
+    const skeleton = await context.org.getSkeleton();
+    const accountQuery = args.account?.toLowerCase();
+    const candidates = accountQuery
+        ? skeleton.namespaces.filter((candidate) => (candidate.account_name ?? "").toLowerCase().includes(accountQuery))
+        : skeleton.namespaces;
+    if (accountQuery && candidates.length === 0) {
+        const accounts = [
+            ...new Set(skeleton.namespaces.map((candidate) => candidate.account_name).filter(Boolean)),
+        ];
+        return {
+            out: fail(translate("createApp.noAccountMatch", { account: args.account ?? "", names: accounts.join(", ") })),
+        };
+    }
+    let namespace = args.namespace_id
+        ? candidates.find((candidate) => candidate.id === args.namespace_id)
+        : undefined;
+    if (!namespace && args.namespace) {
+        const query = args.namespace.toLowerCase();
+        const matches = candidates.filter((candidate) => candidate.name.toLowerCase().includes(query));
+        if (matches.length === 1)
+            namespace = matches[0];
+        else if (matches.length === 0) {
+            return {
+                out: fail(translate("createApp.noNamespaceMatch", {
+                    namespace: args.namespace,
+                    names: candidates.map((candidate) => candidate.name).join(", "),
+                })),
+            };
+        }
+    }
+    // One namespace in scope (the whole org, or the chosen account) → auto-pick it.
+    if (!namespace && candidates.length === 1)
+        namespace = candidates[0];
+    if (!namespace) {
+        if (skeleton.namespaces.length === 0)
+            return { out: fail(translate("createApp.noNamespaces")) };
+        return {
+            out: await buildFormReply(context, {
+                name,
+                account: args.account,
+                namespace: args.namespace,
+                template: args.template,
+                template_id: args.template_id,
+                repository_url: repoUrl,
+            }),
+        };
+    }
+    return { namespace };
+}
+/** The convergent "this repo is already an app" reply — shared by the pre-create check and the
+ *  create-conflict recovery (a retried create that hit "already exists"), so both read identically. */
+async function reusedAppReply(context, app, repoUrl) {
+    const orgSlug = await context.org.organizationSlug();
+    return reply(translate("createApp.alreadyLinked", { name: app.name, id: app.id, repo: repoUrl }) +
+        next(translate("createApp.createdHint")) +
+        linkLine(translate("md.dashboard"), dashboardLink(orgSlug, app.nrn)), {
+        application: { id: app.id, name: app.name, status: app.status, nrn: app.nrn },
+        reused: true,
+    });
+}
+/** Poll a freshly-created app briefly (pending → active), then build its reply — ready vs still-
+ *  provisioning, with the next-step hint (a scaffolded NEW repo must be cloned before building). */
+async function provisioningReply(context, created, details) {
+    let app = created;
+    for (let attempt = 0; attempt < 8 && app.status === "pending"; attempt++) {
+        await sleep(delays.appPoll);
+        app = await getApplication(context.np, created.id).catch(() => app);
+    }
+    const orgSlug = await context.org.organizationSlug();
+    const dashboard = linkLine(translate("md.dashboard"), dashboardLink(orgSlug, app.nrn));
+    const recentMessages = (app.messages ?? [])
+        .slice(-3)
+        .map((entry) => `- ${entry.message ?? JSON.stringify(entry)}`)
+        .join("\n");
+    const structured = {
+        application: { id: app.id, name: details.name, status: app.status, nrn: app.nrn },
+        scaffolded: details.scaffolded,
+        repository_url: details.repoUrl,
+    };
+    const createdHint = details.scaffolded
+        ? translate("createApp.createdHintNew", { repo: details.repoUrl })
+        : translate("createApp.createdHint");
+    if (app.status === "active") {
+        return reply(`${glyph("active")} ${translate("createApp.created", { name: details.name, id: app.id, namespace: details.namespaceName, repo: details.repoUrl })}${recentMessages ? `\n${recentMessages}` : ""}` +
+            next(createdHint) +
+            dashboard, structured);
+    }
+    return reply(`${translate("createApp.pending", { name: details.name, id: app.id, status: app.status })}${recentMessages ? `\n${recentMessages}` : ""}` +
+        next(translate("createApp.pendingHint", { id: app.id })) +
+        dashboard, structured);
+}
 export const createAppTool = defineTool({
     name: TOOL.applicationCreate,
     title: "Create application",
-    description: 'Create a nullplatform application. GATE FIRST: if the request is bare and gives you NOTHING to infer from (e.g. just "create an app" / "create a new application" with no hint of what it\'s for or what to name it), DO NOT call this tool yet — first ask the user, in chat, what the app is for AND what to name it, and WAIT for both; call this only once you have the purpose (to pre-fill the namespace) AND the name in hand. Do NOT call it in the meantime, while still waiting on the name — opening a blank or half-filled form and continuing to ask is a failure, not a fallback. When you DO have context, INFER the best-fitting namespace and account from what the app is FOR (a demo → a demos/examples namespace, a backend service → a services namespace) and pass them as `namespace`/`account` so the form opens pre-selected on your inference — the user can still change it. Calling without `provision:true` opens an interactive form and creates nothing — the user confirms the namespace, then either a NEW repository (scaffolded from a template, repo URL auto-generated) or IMPORTS an existing repository (optionally a monorepo folder), and the form itself submits with provision:true to actually create. Only the form\'s submit sets provision:true; you (the model) NEVER set it and NEVER pass a repository_url to "pre-fill" expecting a create — passing a repository_url without provision just opens the form, it does NOT write anything. Provisioning is async — the create waits briefly and reports progress.',
+    description: 'Create a nullplatform application. THIS IS THE ONE AND ONLY WAY to create/scaffold/set-up/bootstrap a new app, and it is the PLATFORM\'s job: nullplatform itself creates the git repository (on whatever provider the account is configured for — GitHub, GitLab, Bitbucket, …) from a template and provisions it. So for ANY "create / scaffold / set up / build a new app" request, route it HERE — do NOT brainstorm or design the app first, do NOT run an implementation process, do NOT `git init` or write files locally, and do NOT offer a "scaffold locally first" choice or ask "where should it live / how do we deploy": there is no local path, so that is not a real question. Infer the stack and pass it as `template` ON THE FIRST CALL — a SEMANTIC word ("frontend", "react", "go", "python", "api") is enough; the tool resolves it to the namespace\'s real templates and pre-selects the best fit, so do NOT open the form with the template blank and then recommend one in text. Never ask an open "what stack / what scope" brainstorm question. GATE FIRST: if the request is bare and gives you NOTHING to infer from (e.g. just "create an app" / "create a new application" with no hint of what it\'s for or what to name it), DO NOT call this tool yet — first ask the user, in chat, what the app is for AND what to name it, and WAIT for both; call this only once you have the purpose (to pre-fill the namespace) AND the name in hand. Do NOT call it in the meantime, while still waiting on the name — opening a blank or half-filled form and continuing to ask is a failure, not a fallback. When you DO have context, INFER the best-fitting namespace and account from what the app is FOR (a demo → a demos/examples namespace, a backend service → a services namespace) and pass them as `namespace`/`account` so the form opens pre-selected on your inference — the user can still change it. Calling without `provision:true` opens an interactive form and creates nothing — the user confirms the namespace, then either a NEW repository (scaffolded from a template, repo URL auto-generated) or IMPORTS an existing repository (optionally a monorepo folder), and the form itself submits with provision:true to actually create. Only the form\'s submit sets provision:true; you (the model) NEVER set it and NEVER pass a repository_url to "pre-fill" expecting a create — passing a repository_url without provision just opens the form, it does NOT write anything. Provisioning is async — the create waits briefly and reports progress.',
     annotations: { destructiveHint: false, openWorldHint: true },
     widget: "create-app",
     errorKey: "createApp.errorLabel",
@@ -97,7 +200,7 @@ export const createAppTool = defineTool({
         template: z
             .string()
             .optional()
-            .describe('Template/stack to scaffold from — INFER it from what the app is FOR (a Go service → "go", a React frontend → "react"/"node", a Python API → "python") and pass the stack you would choose. The tool matches it against the chosen namespace\'s real templates and pre-selects it; prefer template_id only when you already know the exact id.'),
+            .describe('Stack to scaffold from — ALWAYS pass this on the first call so the form opens with the template ALREADY selected; never open the form with this blank and then recommend a template in text. Two ways to fill it: (1) if a single SEMANTIC word uniquely identifies the stack from the app\'s purpose/name (a Python service → "python", a Go API → "go"), pass that word — the tool matches it to the namespace\'s real templates by name + tags. (2) if a semantic word would be AMBIGUOUS — several templates could match (e.g. multiple frontend kits), or you want the BEST fit for the use case (a bank demo → a bank-themed frontend kit) — you MUST first LIST the templates headlessly with `entity_list entity:"template" parent_type:"namespace" parent_id:<namespace_id>` (NO panel), pick the SPECIFIC one, and pass its name here. Do the entity_list BEFORE opening this form. (prefer template_id only when you already know the exact id.)'),
         template_id: z
             .number()
             .optional()
@@ -132,24 +235,8 @@ export const createAppTool = defineTool({
         }
         // Convergent under retries: a repo already linked to an app returns that app, never a duplicate.
         const alreadyLinked = await context.org.inferAppFromRepo(repoUrl);
-        if (alreadyLinked) {
-            const orgSlug = await context.org.organizationSlug();
-            return reply(translate("createApp.alreadyLinked", {
-                name: alreadyLinked.name,
-                id: alreadyLinked.id,
-                repo: repoUrl,
-            }) +
-                next(translate("createApp.createdHint")) +
-                linkLine(translate("md.dashboard"), dashboardLink(orgSlug, alreadyLinked.nrn)), {
-                application: {
-                    id: alreadyLinked.id,
-                    name: alreadyLinked.name,
-                    status: alreadyLinked.status,
-                    nrn: alreadyLinked.nrn,
-                },
-                reused: true,
-            });
-        }
+        if (alreadyLinked)
+            return reusedAppReply(context, alreadyLinked, repoUrl);
         const name = args.name ??
             repoUrl
                 .split("/")
@@ -157,51 +244,12 @@ export const createAppTool = defineTool({
                 ?.replace(/\.git$/, "");
         if (!name)
             return fail(translate("createApp.noName", { url: repoUrl }));
-        // Resolve where the app lives — an (account, namespace) pair. Narrow to the named account first
-        // (a namespace name can repeat across accounts), then match/auto-pick the namespace inside it.
-        // If it still can't be pinned down and there's a real choice, fall back to the form (a picker)
-        // rather than a dead-end ask.
-        const skeleton = await context.org.getSkeleton();
-        const accountQuery = args.account?.toLowerCase();
-        const candidates = accountQuery
-            ? skeleton.namespaces.filter((candidate) => (candidate.account_name ?? "").toLowerCase().includes(accountQuery))
-            : skeleton.namespaces;
-        if (accountQuery && candidates.length === 0) {
-            const accounts = [
-                ...new Set(skeleton.namespaces.map((candidate) => candidate.account_name).filter(Boolean)),
-            ];
-            return fail(translate("createApp.noAccountMatch", { account: args.account ?? "", names: accounts.join(", ") }));
-        }
-        let namespace = args.namespace_id
-            ? candidates.find((candidate) => candidate.id === args.namespace_id)
-            : undefined;
-        if (!namespace && args.namespace) {
-            const query = args.namespace.toLowerCase();
-            const matches = candidates.filter((candidate) => candidate.name.toLowerCase().includes(query));
-            if (matches.length === 1)
-                namespace = matches[0];
-            else if (matches.length === 0) {
-                return fail(translate("createApp.noNamespaceMatch", {
-                    namespace: args.namespace,
-                    names: candidates.map((candidate) => candidate.name).join(", "),
-                }));
-            }
-        }
-        // One namespace in scope (the whole org, or the chosen account) → auto-pick it.
-        if (!namespace && candidates.length === 1)
-            namespace = candidates[0];
-        if (!namespace) {
-            if (skeleton.namespaces.length === 0)
-                return fail(translate("createApp.noNamespaces"));
-            return buildFormReply(context, {
-                name,
-                account: args.account,
-                namespace: args.namespace,
-                template: args.template,
-                template_id: args.template_id,
-                repository_url: repoUrl,
-            });
-        }
+        // Resolve where the app lives — an (account, namespace) pair. Returns the pinned namespace, or
+        // an `out` reply (a fail on no match, or the form picker when it's a real choice) — see the helper.
+        const resolvedNamespace = await resolveCreateNamespace(context, args, name, repoUrl);
+        if ("out" in resolvedNamespace)
+            return resolvedNamespace.out;
+        const namespace = resolvedNamespace.namespace;
         let created;
         try {
             created = await createApplication(context.np, {
@@ -222,50 +270,16 @@ export const createAppTool = defineTool({
                 (await context.org.findApps({ query: name, namespace: namespace.name }).catch(() => [])).find((candidate) => candidate.name.toLowerCase() === name.toLowerCase() && candidate.namespace_id === namespace.id);
             if (!existing)
                 throw caught;
-            const orgSlug = await context.org.organizationSlug();
-            return reply(translate("createApp.alreadyLinked", { name: existing.name, id: existing.id, repo: repoUrl }) +
-                next(translate("createApp.createdHint")) +
-                linkLine(translate("md.dashboard"), dashboardLink(orgSlug, existing.nrn)), {
-                application: {
-                    id: existing.id,
-                    name: existing.name,
-                    status: existing.status,
-                    nrn: existing.nrn,
-                },
-                reused: true,
-            });
+            return reusedAppReply(context, existing, repoUrl);
         }
-        // Provisioning is async (pending -> active); wait briefly so the common case answers "ready".
-        let app = created;
-        for (let attempt = 0; attempt < 8 && app.status === "pending"; attempt++) {
-            await sleep(delays.appPoll);
-            app = await getApplication(context.np, created.id).catch(() => app);
-        }
-        const orgSlug = await context.org.organizationSlug();
-        const dashboard = linkLine(translate("md.dashboard"), dashboardLink(orgSlug, app.nrn));
-        const recentMessages = (app.messages ?? [])
-            .slice(-3)
-            .map((entry) => `- ${entry.message ?? JSON.stringify(entry)}`)
-            .join("\n");
         // A new repo scaffolded from a template is a fresh REMOTE repo the developer has never cloned —
-        // the next move is to pull it into a folder and build there. An import is already local, so its
-        // next move is just to push. The two paths get different guidance.
-        const scaffolded = args.template_id !== undefined;
-        const structured = {
-            application: { id: app.id, name, status: app.status, nrn: app.nrn },
-            scaffolded,
-            repository_url: repoUrl,
-        };
-        const createdHint = scaffolded
-            ? translate("createApp.createdHintNew", { repo: repoUrl })
-            : translate("createApp.createdHint");
-        if (app.status === "active") {
-            return reply(`${glyph("active")} ${translate("createApp.created", { name, id: app.id, namespace: namespace.name, repo: repoUrl })}${recentMessages ? `\n${recentMessages}` : ""}` +
-                next(createdHint) +
-                dashboard, structured);
-        }
-        return reply(`${translate("createApp.pending", { name, id: app.id, status: app.status })}${recentMessages ? `\n${recentMessages}` : ""}` +
-            next(translate("createApp.pendingHint", { id: app.id })) +
-            dashboard, structured);
+        // its next move is to clone-then-build; an import is already local, so it just pushes. The two
+        // paths get different guidance (carried by `scaffolded`). Poll briefly so the common case is ready.
+        return provisioningReply(context, created, {
+            name,
+            namespaceName: namespace.name,
+            repoUrl,
+            scaffolded: args.template_id !== undefined,
+        });
     },
 });

package/dist/tools/create-link.js

@@ -9,6 +9,71 @@ const slug = (text) => text
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, "-")
     .replace(/^-+|-+$/g, "");
+/**
+ * Pick which provisioned service to link from the `service` hint. Mirrors requireApp's shape:
+ * returns the single matched service, or an `out` reply — a `fail` when the app has no linkable
+ * services, or the pick-service panel when the hint is missing/ambiguous (zero or many matches).
+ */
+async function resolveLinkService(context, app, serviceHint, dashboard) {
+    const services = (await listAppServices(context.np, app.nrn)).filter((service) => service.status !== "failed");
+    if (services.length === 0) {
+        return {
+            out: fail(translate("createLink.noServices", { app: app.name }) + next(translate("createLink.noServicesHint"))),
+        };
+    }
+    const wanted = serviceHint?.toLowerCase();
+    const matched = wanted
+        ? services.filter((service) => service.name.toLowerCase().includes(wanted) || service.id === serviceHint)
+        : [];
+    if (matched.length === 1)
+        return { service: matched[0] };
+    // Zero or many matches → let the user pick (the panel lists the candidates, or all services).
+    const list = matched.length > 1 ? matched : services;
+    const md = `${translate(matched.length > 1 ? "createLink.matchAmbiguous" : "createLink.pickService", {
+        app: app.name,
+    })}\n\n${table([translate("header.name"), translate("header.status")], list.map((service) => [service.name, service.status]))}${next(translate("createLink.pickHint"))}`;
+    return {
+        out: reply(md, {
+            mode: "pick-service",
+            app: `#${app.id}`,
+            app_name: app.name,
+            services: list,
+            dashboard,
+        }),
+    };
+}
+/**
+ * Create the link, or reuse an existing non-failed one on the same target (convergent under
+ * retries). A credential link (linkCreate present) is created WITHOUT activate-now and then has its
+ * create-action enqueued — the agent provisions it; a plain link activates immediately on creation.
+ */
+async function createOrReuseLink(context, input) {
+    const { service, target, linkSpec, linkCreate } = input;
+    const existing = (await listLinks(context.np, target.nrn)).find((link) => link.service_id === service.id && link.status !== "failed");
+    if (existing) {
+        return { link: { id: existing.id, status: existing.status, service_id: service.id }, reused: true };
+    }
+    const link = await createLink(context.np, {
+        name: `lnk ${slug(service.name)}`,
+        service_id: service.id,
+        entity_nrn: target.nrn,
+        specification_id: linkSpec.id,
+        dimensions: target.dimensions,
+        // No create action → no agent will provision it, so it MUST be sent active or it sticks
+        // `pending` forever. With one, OMIT status and enqueue the create action.
+        activateImmediately: !linkCreate,
+    });
+    if (linkCreate) {
+        // THE link action — POST /link/{id}/action with the link's own parameters (e.g. the
+        // database-user's permissions). Without it the link is `pending` with no credentials.
+        await createLinkAction(context.np, link.id, {
+            name: `create-${slug(service.name)}-link`,
+            specification_id: linkCreate.id,
+            parameters: input.parameters ?? {},
+        });
+    }
+    return { link, reused: false };
+}
 /**
  * Link a provisioned dependency service to an application or one of its scopes — a SEPARATE
  * operation from provisioning it (`application_service_create`). Creating the link is one or two
@@ -52,29 +117,11 @@ export const createLinkTool = defineTool({
             return fail(translate("resolve.noNrn", { app: app.name }));
         const orgSlug = await context.org.organizationSlug();
         const dashboard = dashboardLink(orgSlug, app.nrn);
-        // The app's provisioned services — pick which one to link.
-        const services = (await listAppServices(context.np, app.nrn)).filter((service) => service.status !== "failed");
-        if (services.length === 0) {
-            return fail(translate("createLink.noServices", { app: app.name }) + next(translate("createLink.noServicesHint")));
-        }
-        const wanted = args.service?.toLowerCase();
-        const matched = wanted
-            ? services.filter((service) => service.name.toLowerCase().includes(wanted) || service.id === args.service)
-            : [];
-        if (matched.length !== 1) {
-            const list = matched.length > 1 ? matched : services;
-            const md = `${translate(matched.length > 1 ? "createLink.matchAmbiguous" : "createLink.pickService", {
-                app: app.name,
-            })}\n\n${table([translate("header.name"), translate("header.status")], list.map((service) => [service.name, service.status]))}${next(translate("createLink.pickHint"))}`;
-            return reply(md, {
-                mode: "pick-service",
-                app: `#${app.id}`,
-                app_name: app.name,
-                services: list,
-                dashboard,
-            });
-        }
-        const service = matched[0];
+        // The app's provisioned services — pick which one to link (or surface the picker / no-services fail).
+        const resolvedService = await resolveLinkService(context, { id: app.id, name: app.name, nrn: app.nrn }, args.service, dashboard);
+        if ("out" in resolvedService)
+            return resolvedService.out;
+        const service = resolvedService.service;
         // The link spec that applies to this service + its create-action (the form's params). Prefer the
         // spec that PROVISIONS credentials (use_default_actions) — e.g. Postgres `database-user`.
         const linkSpecs = service.specification_id
@@ -116,37 +163,17 @@ export const createLinkTool = defineTool({
                 dashboard,
             });
         }
-        // ---- CREATE LINK ----
-        // Convergent: an existing link for this service on this target → reuse, never duplicate.
-        const existing = (await listLinks(context.np, target.nrn)).find((link) => link.service_id === service.id && link.status !== "failed");
-        let link;
-        if (existing) {
-            link = { id: existing.id, status: existing.status, service_id: service.id };
-        }
-        else {
-            link = await createLink(context.np, {
-                name: `lnk ${slug(service.name)}`,
-                service_id: service.id,
-                entity_nrn: target.nrn,
-                specification_id: linkSpec.id,
-                dimensions: target.dimensions,
-                // No create action → no agent will provision it, so it MUST be sent active or it sticks
-                // `pending` forever. With one, OMIT status and enqueue the create action below.
-                activateImmediately: !linkCreate,
-            });
-            if (linkCreate) {
-                // THE link action — POST /link/{id}/action with the link's own parameters (e.g. the
-                // database-user's permissions). Without it the link is `pending` with no credentials.
-                await createLinkAction(context.np, link.id, {
-                    name: `create-${slug(service.name)}-link`,
-                    specification_id: linkCreate.id,
-                    parameters: args.parameters ?? {},
-                });
-            }
-        }
+        // Create the link (or reuse a non-failed one on this target — convergent under retries).
+        const { link: linked, reused } = await createOrReuseLink(context, {
+            service,
+            target,
+            linkSpec,
+            linkCreate,
+            parameters: args.parameters,
+        });
         await sleep(delays.appPoll);
-        link = await getLink(context.np, link.id).catch(() => link);
-        const headline = existing
+        const link = await getLink(context.np, linked.id).catch(() => linked);
+        const headline = reused
             ? translate("createLink.reused", { service: service.name, target: target.label, status: link.status })
             : translate("createLink.linking", { service: service.name, target: target.label, status: link.status });
         const md = `${headline}${next(translate("createLink.linkedHint"))}${linkLine(translate("md.dashboard"), dashboard)}`;
@@ -156,7 +183,7 @@ export const createLinkTool = defineTool({
             app_name: app.name,
             service: { id: service.id, name: service.name },
             link: { id: link.id, status: link.status, target: target.label },
-            reused: Boolean(existing),
+            reused,
             dashboard,
         });
     },

package/dist/tools/create-scope.js

@@ -6,13 +6,41 @@ import { defineTool, fail, reply } from "../tool.js";
 import { TOOL } from "../tool-names.js";
 import { appArg, dimsLabel, requireApp } from "./shared.js";
 import { buildAppStatus } from "./status.js";
+/**
+ * Resolve the scope `type` (+ provider) to provision with. An explicit `type` wins; otherwise, for
+ * an app with an NRN, auto-pick the org's single scope type. Mirrors requireApp's shape: returns
+ * { type, provider } (type left undefined when there are none — the handler fails on that), or an
+ * `out` reply — the which-type form (riding the overview) when the org offers several.
+ */
+async function resolveScopeType(context, app, scopeName, argType, argProvider) {
+    if (argType || !app.nrn)
+        return { type: argType, provider: argProvider };
+    const scopeTypes = await listScopeTypes(context.np, app.nrn);
+    const onlyType = scopeTypes.length === 1 ? scopeTypes[0] : undefined;
+    if (onlyType) {
+        return { type: onlyType.type ?? onlyType.name, provider: argProvider ?? onlyType.provider ?? undefined };
+    }
+    if (scopeTypes.length > 1) {
+        // The create-scope form picks a type from scope_types; the overview rides along so a fresh app
+        // (no scopes yet) renders that form instead of an empty panel.
+        const { structured } = await buildAppStatus(context, app);
+        return {
+            out: reply(`${translate("createScope.whichType", { name: scopeName })}\n\n${table([translate("header.type"), translate("header.name"), translate("header.provider")], scopeTypes.map((scopeType) => [
+                scopeType.type ?? "",
+                scopeType.name ?? "",
+                scopeType.provider ?? "",
+            ]))}${next(translate("createScope.typeHint", { name: scopeName }))}`, { ...structured, scope_types: scopeTypes }),
+        };
+    }
+    return { type: argType, provider: argProvider };
+}
 export const createScopeTool = defineTool({
     name: TOOL.applicationScopeCreate,
     title: "Create scope",
     description: 'Create a SCOPE — a deploy target (e.g. dev/staging/main) — for an application; provisions real infrastructure asynchronously. Use it for "add a dev/staging/prod environment", "create a scope", "set up a new deploy target". Pass `name`; the scope `type` is inferred or auto-pinned when the org has one, else the form lists the org\'s types to pick from; `dimensions` default to the shape of an existing scope when the org uses them. Convergent: an existing scope of the same name is returned, never duplicated. Renders the app panel; once active, deploy to it with application_deployment_create scope:"<name>".',
     // Convergent under retries (reuses the scope-by-name), so idempotent.
     annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    widget: "np-panel",
+    widget: "status",
     errorKey: "createScope.errorLabel",
     inputSchema: {
         app: appArg,
@@ -42,26 +70,10 @@ export const createScopeTool = defineTool({
                 next(translate("createScope.provisioningHint", { name: existing.name })) +
                 linkLine(translate("md.dashboard"), dashboardLink(orgSlug, existing.nrn)), { ...status.structured, scope: existing, reused: true });
         }
-        let type = args.type;
-        let provider = args.provider;
-        if (!type && app.nrn) {
-            const scopeTypes = await listScopeTypes(context.np, app.nrn);
-            const onlyType = scopeTypes.length === 1 ? scopeTypes[0] : undefined;
-            if (onlyType) {
-                type = onlyType.type ?? onlyType.name;
-                provider = provider ?? onlyType.provider ?? undefined;
-            }
-            else if (scopeTypes.length > 1) {
-                // np-panel's create-scope form picks a type from scope_types; the overview rides along
-                // so a fresh app (no scopes yet) renders that form instead of an empty panel.
-                const { structured } = await buildAppStatus(context, app);
-                return reply(`${translate("createScope.whichType", { name: args.name })}\n\n${table([translate("header.type"), translate("header.name"), translate("header.provider")], scopeTypes.map((scopeType) => [
-                    scopeType.type ?? "",
-                    scopeType.name ?? "",
-                    scopeType.provider ?? "",
-                ]))}${next(translate("createScope.typeHint", { name: args.name }))}`, { ...structured, scope_types: scopeTypes });
-            }
-        }
+        const typeResult = await resolveScopeType(context, app, args.name, args.type, args.provider);
+        if ("out" in typeResult)
+            return typeResult.out;
+        const { type, provider } = typeResult;
         if (!type)
             return fail(translate("createScope.noTypes"));
         // Orgs with runtime dimensions usually require them — borrow the shape from a sibling scope.
@@ -78,7 +90,7 @@ export const createScopeTool = defineTool({
             provider,
             dimensions,
         });
-        // Hand off into np-panel: the overview now includes the provisioning scope, so the panel
+        // Hand off into the status panel: the overview now includes the provisioning scope, so the panel
         // shows it alongside a Deploy button — the literal next move (read-after-write).
         const [orgSlug, status] = await Promise.all([
             context.org.organizationSlug(),

package/dist/tools/create-service.js

@@ -19,6 +19,38 @@ function matchSpecs(specs, query) {
     });
 }
 const specCategory = (spec) => [spec.category, spec.subCategory].filter(Boolean).join(" › ");
+/**
+ * Pick which catalog dependency to provision from the `specification_id` / `type` hints. Mirrors
+ * requireApp's shape: returns the matched spec, or an `out` reply — a `fail` when the app's catalog
+ * is empty, or the pick-spec panel when the hint is missing/ambiguous (resolved via the shared
+ * resolveChoice on name + category + sub-category, never an arbitrary first entry).
+ */
+async function resolveServiceSpec(context, app, hints, dashboard) {
+    const specs = await listDependencySpecs(context.np, app.nrn);
+    if (specs.length === 0) {
+        return {
+            out: fail(translate("createService.noSpecs", { app: app.name }) +
+                linkLine(translate("md.dashboard"), dashboard)),
+        };
+    }
+    const spec = resolveChoice(specs, { id: hints.specification_id, text: hints.type }, {
+        haystack: (candidate) => `${candidate.name} ${candidate.category ?? ""} ${candidate.subCategory ?? ""}`,
+    });
+    if (spec)
+        return { spec };
+    // None / ambiguous → return the catalog (or the narrowed matches) to pick from.
+    const typed = hints.type ? matchSpecs(specs, hints.type) : [];
+    const list = typed.length > 1 ? typed : specs;
+    const heading = translate(typed.length > 1 ? "createService.matchAmbiguous" : "createService.pickSpec", {
+        app: app.name,
+        query: hints.type ?? "",
+        count: specs.length,
+    });
+    const md = `${heading}\n\n${table([translate("header.name"), translate("createService.category"), translate("createService.provider")], list.map((candidate) => [candidate.name, specCategory(candidate), candidate.provider ?? ""]))}${next(translate("createService.pickHint"))}`;
+    return {
+        out: reply(md, { mode: "pick-spec", app: `#${app.id}`, app_name: app.name, specs: list, dashboard }),
+    };
+}
 /**
  * Provision a dependency service (the service record + its create action). Linking it to an app or
  * scope is a SEPARATE operation (`application_link_create`) — two distinct platform entities with
@@ -27,7 +59,7 @@ const specCategory = (spec) => [spec.category, spec.subCategory].filter(Boolean)
 export const createServiceTool = defineTool({
     name: TOOL.applicationServiceCreate,
     title: "Provision service",
-    description: 'Provision a dependency service (SQL database, queue, cache, …) for an application. Pass `type` to choose the dependency (e.g. "postgres", "redis"). Provisioning creates real cloud resources (cost-bearing) and runs asynchronously, so call WITHOUT `provision:true` first to open the form; the user confirms by submitting it. Once it is active, LINK it to a scope with application_link_create so its connection details flow in as parameters.',
+    description: 'Provision a dependency service (SQL database, queue, cache, …) for an application. ALWAYS pass a SEMANTIC `type` from what the user asked for (e.g. "postgres", "redis", "queue", "cache") — you do NOT need the exact catalog spec name/id; the tool matches your word to the real catalog and pre-selects it, so the form opens with the dependency already chosen. Do NOT open the form with no `type` and then list the catalog or recommend one in text — pre-select it. Provisioning creates real cloud resources (cost-bearing) and runs asynchronously, so call WITHOUT `provision:true` first to open the form; the user confirms by submitting it. Once it is active, LINK it to a scope with application_link_create so its connection details flow in as parameters.',
     annotations: { destructiveHint: false, openWorldHint: true },
     widget: "service-create",
     errorKey: "createService.errorLabel",
@@ -60,29 +92,11 @@ export const createServiceTool = defineTool({
             return fail(translate("resolve.noNrn", { app: app.name }));
         const orgSlug = await context.org.organizationSlug();
         const dashboard = dashboardLink(orgSlug, app.nrn);
-        // The provisionable catalog (core API — carries the action specs the write path needs).
-        const specs = await listDependencySpecs(context.np, app.nrn);
-        if (specs.length === 0) {
-            return fail(translate("createService.noSpecs", { app: app.name }) +
-                linkLine(translate("md.dashboard"), dashboard));
-        }
-        // Pre-select via the shared resolver (same rule as namespace/template): an exact spec id (form
-        // submit) or the model's `type` hint, matched against the catalog on name + category + sub-category.
-        // None / ambiguous → return the catalog (or the narrowed matches) to pick from — never an arbitrary one.
-        const spec = resolveChoice(specs, { id: args.specification_id, text: args.type }, {
-            haystack: (candidate) => `${candidate.name} ${candidate.category ?? ""} ${candidate.subCategory ?? ""}`,
-        });
-        if (!spec) {
-            const typed = args.type ? matchSpecs(specs, args.type) : [];
-            const list = typed.length > 1 ? typed : specs;
-            const heading = translate(typed.length > 1 ? "createService.matchAmbiguous" : "createService.pickSpec", {
-                app: app.name,
-                query: args.type ?? "",
-                count: specs.length,
-            });
-            const md = `${heading}\n\n${table([translate("header.name"), translate("createService.category"), translate("createService.provider")], list.map((candidate) => [candidate.name, specCategory(candidate), candidate.provider ?? ""]))}${next(translate("createService.pickHint"))}`;
-            return reply(md, { mode: "pick-spec", app: `#${app.id}`, app_name: app.name, specs: list, dashboard });
-        }
+        // The provisionable catalog → pre-select the spec (or surface the picker / empty-catalog fail).
+        const resolvedSpec = await resolveServiceSpec(context, { id: app.id, name: app.name, nrn: app.nrn }, { specification_id: args.specification_id, type: args.type }, dashboard);
+        if ("out" in resolvedSpec)
+            return resolvedSpec.out;
+        const spec = resolvedSpec.spec;
         const createAction = await serviceCreateActionSpec(context.np, spec.id);
         const name = (args.name ?? spec.name).trim();
         // Form-first: no explicit provision OR a required create-action param still missing → show the