@nullplatform/mcp 0.1.3 → 0.1.5

package/dist/i18n.js

@@ -51,6 +51,9 @@ const english = {
     "header.live": "Live",
     "header.traffic": "Traffic",
     "header.when": "When",
+    "header.version": "Version",
+    "header.build": "Build",
+    "header.release": "Release",
     // — markdown design language —
     "md.next": "Next",
     "md.none": "_none_",
@@ -168,6 +171,16 @@ const english = {
     "builds.assetsTitle": "Assets of build #{build}",
     "builds.noAssets": "Build #{build} has no assets (it may still be building).",
     "builds.errorLabel": "Couldn't list builds",
+    "releaseList.title": "**{app}** · {count} release(s)",
+    "releaseList.none": "**{app}** has no releases yet.",
+    "releaseList.noneHint": "cut one from a successful build with `application_release_create`, or just `application_deployment_create`.",
+    "releaseList.deployHint": 'deploy an active release with `application_deployment_create version:"x.y.z"`.',
+    "releaseList.errorLabel": "Couldn't list releases",
+    "deploymentList.title": "**{app}** · {count} deployment(s)",
+    "deploymentList.none": "**{app}** has no deployments yet.",
+    "deploymentList.group": "{count} scopes (group)",
+    "deploymentList.hint": "`application_get` for the live picture, or `application_deployment_update` to drive a rollout.",
+    "deploymentList.errorLabel": "Couldn't list deployments",
     // — organization_get tool —
     "overview.title": "Organization overview · {count} application(s) scanned",
     "overview.truncated": '_(showing the first {count} — narrow with `organization_get query:"..."`)_',
@@ -325,6 +338,9 @@ const spanish = {
     "header.live": "En vivo",
     "header.traffic": "Tráfico",
     "header.when": "Cuándo",
+    "header.version": "Versión",
+    "header.build": "Build",
+    "header.release": "Release",
     "md.next": "Siguiente",
     "md.none": "_ninguno_",
     "md.justNow": "recién",
@@ -432,6 +448,16 @@ const spanish = {
     "builds.assetsTitle": "Assets del build #{build}",
     "builds.noAssets": "El build #{build} no tiene assets (puede estar compilando todavía).",
     "builds.errorLabel": "No pude listar los builds",
+    "releaseList.title": "**{app}** · {count} release(s)",
+    "releaseList.none": "**{app}** todavía no tiene releases.",
+    "releaseList.noneHint": "cortá uno desde un build exitoso con `application_release_create`, o directamente `application_deployment_create`.",
+    "releaseList.deployHint": 'deployá un release activo con `application_deployment_create version:"x.y.z"`.',
+    "releaseList.errorLabel": "No pude listar los releases",
+    "deploymentList.title": "**{app}** · {count} deployment(s)",
+    "deploymentList.none": "**{app}** todavía no tiene deployments.",
+    "deploymentList.group": "{count} scopes (grupo)",
+    "deploymentList.hint": "`application_get` para la foto en vivo, o `application_deployment_update` para conducir un rollout.",
+    "deploymentList.errorLabel": "No pude listar los deployments",
     // — organization_get tool —
     "overview.title": "Panorama de la organización · {count} aplicación(es) escaneada(s)",
     "overview.truncated": '_(muestro las primeras {count} — acotá con `organization_get query:"..."`)_',

package/dist/np/journey.js

@@ -26,6 +26,8 @@ export async function listBuilds(np, applicationId, options = {}) {
     // canonical OpenAPI contract) — this is how a change is traced from a commit to its build.
     if (options.commit)
         query["commit.id"] = options.commit;
+    if (options.offset)
+        query.offset = options.offset;
     const page = await np.get("/build", query).catch(() => ({ results: [] }));
     return (page.results ?? []).map((build) => ({
         id: build.id,
@@ -52,6 +54,8 @@ export async function listReleases(np, applicationId, options = {}) {
     };
     if (options.status)
         query.status = options.status;
+    if (options.offset)
+        query.offset = options.offset;
     const page = await np
         .get("/release", query)
         .catch(() => ({ results: [] }));
@@ -195,6 +199,25 @@ export async function listScopeDeployments(np, scopeId, limit = 3) {
         .catch(() => ({ results: [] }));
     return (page.results ?? []).map(mapDeployment);
 }
+/** Every deployment of an application, newest first — the public `/deployment` endpoint accepts
+ *  `application_id`. Group rows (`type: "deployment_group"`) carry their per-scope children. */
+export async function listDeployments(np, applicationId, options = {}) {
+    const query = {
+        application_id: applicationId,
+        sort: "created_at:desc",
+        limit: options.limit ?? 50,
+    };
+    if (options.offset)
+        query.offset = options.offset;
+    const page = await np
+        .get("/deployment", query)
+        .catch(() => ({ results: [] }));
+    return (page.results ?? []).map((row) => ({
+        ...mapDeployment(row),
+        type: row.type,
+        deployments: row.deployments?.map(mapDeployment),
+    }));
+}
 /**
  * Traffic switch — the public API takes desiredSwitchedTraffic (camelCase INSIDE the
  * snake_case strategy_data envelope; verified live) and moves traffic toward it.
@@ -243,9 +266,12 @@ export async function setParameters(np, nrn, params) {
     return { created, updated };
 }
 /** Read parameters — NRN-scoped on the public API; returns undefined when unavailable. */
-export async function listParameters(np, nrn) {
+export async function listParameters(np, nrn, options = {}) {
     try {
-        const page = await np.get("/parameter", { nrn, limit: 100 });
+        const query = { nrn, limit: options.limit ?? 100 };
+        if (options.offset)
+            query.offset = options.offset;
+        const page = await np.get("/parameter", query);
         return (page.results ?? []).map((parameter) => ({
             id: parameter.id,
             name: parameter.name,

package/dist/tool-names.js

@@ -12,6 +12,8 @@ export const TOOL = {
     applicationLogList: "application_log_list",
     applicationMetricList: "application_metric_list",
     applicationBuildList: "application_build_list",
+    applicationReleaseList: "application_release_list",
+    applicationDeploymentList: "application_deployment_list",
     applicationParameterList: "application_parameter_list",
     applicationParameterCreate: "application_parameter_create",
     applicationDeploymentCreate: "application_deployment_create",

package/dist/tools/approvals.js

@@ -16,6 +16,7 @@ export const approvalsTool = defineTool({
     title: "Approvals",
     description: 'List the approvals gating an application\'s actions (e.g. a deployment waiting on a policy), and act on one. action:"approve" lets the gated action proceed; action:"cancel" cancels the request. Both use your own permissions — the platform denies what you\'re not allowed to do. Use this when a deploy is stuck in creating_approval.',
     annotations: { destructiveHint: false, openWorldHint: true },
+    widget: "approvals",
     errorKey: "approvals.errorLabel",
     inputSchema: {
         app: appArg,

package/dist/tools/builds.js

@@ -4,7 +4,7 @@ import { ago, glyph, next, shortCommit, table } from "../md.js";
 import { listAssets, listBuilds, listReleases } from "../np/journey.js";
 import { defineTool, reply } from "../tool.js";
 import { TOOL } from "../tool-names.js";
-import { appArg, requireApp } from "./shared.js";
+import { appArg, offsetArg, pageOf, requireApp } from "./shared.js";
 /**
  * Closes the hole in the ship loop: between "push a commit" and "deploy" sits CI, and the
  * agent needs to see builds land. status only shows the latest; this lists recent builds,
@@ -15,6 +15,7 @@ export const buildsTool = defineTool({
     title: "Builds",
     description: "List an application's recent CI builds — status, branch, commit, age, and whether each is already released. Use it to answer 'did my push build yet?' and to pick a build_id to deploy. Pass build:<id> to see that build's assets, or commit:<sha> to find the build for a specific commit (tracing a change to its build and release).",
     annotations: { readOnlyHint: true, openWorldHint: true },
+    widget: "builds",
     errorKey: "builds.errorLabel",
     inputSchema: {
         app: appArg,
@@ -24,6 +25,7 @@ export const buildsTool = defineTool({
             .string()
             .optional()
             .describe("Full commit SHA — list only the build(s) for that commit (tracing a change to its build/release)"),
+        offset: offsetArg,
     },
     async handler(args, context) {
         const resolved = await requireApp(context, args);
@@ -47,7 +49,7 @@ export const buildsTool = defineTool({
             return reply(markdown, { build_id: args.build, assets });
         }
         const [builds, releases] = await Promise.all([
-            listBuilds(context.np, app.id, { limit: args.limit ?? 10, commit: args.commit }),
+            listBuilds(context.np, app.id, { limit: args.limit ?? 10, commit: args.commit, offset: args.offset }),
             listReleases(context.np, app.id, { limit: 50 }),
         ]);
         if (builds.length === 0) {
@@ -86,6 +88,7 @@ export const buildsTool = defineTool({
                 released: releasedBuildIds.has(build.id),
                 release_semver: releaseByBuild.get(build.id)?.semver ?? null,
             })),
+            page: pageOf(builds.length, args.limit ?? 10, args.offset ?? 0),
         });
     },
 });

package/dist/tools/create-release.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { translate } from "../i18n.js";
 import { ago, glyph, next, shortCommit } from "../md.js";
-import { createRelease, findActiveReleaseForBuild, listBuilds } from "../np/journey.js";
+import { createRelease, findActiveReleaseForBuild, listBuilds, listReleases } from "../np/journey.js";
 import { defineTool, fail, reply } from "../tool.js";
 import { TOOL } from "../tool-names.js";
 import { appArg, requireApp } from "./shared.js";
@@ -9,7 +9,9 @@ export const createReleaseTool = defineTool({
     name: TOOL.applicationReleaseCreate,
     title: "Create release",
     description: "Cut an active release from a build (default: the latest successful build; semver auto-bumps the patch). Usually you can just call deploy, which does this for you.",
-    annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    // Convergent under retries (reuses the active release-for-build), so idempotent.
+    annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    widget: "releases",
     errorKey: "createRelease.errorLabel",
     inputSchema: {
         app: appArg,
@@ -40,13 +42,17 @@ export const createReleaseTool = defineTool({
         // (matching the requested semver, if any), return it instead of minting a duplicate.
         const existing = await findActiveReleaseForBuild(context.np, app.id, buildId, args.semver);
         if (existing) {
-            return reply(`${glyph("active")} ${translate("createRelease.exists", { semver: existing.semver, build: buildId })}${next(translate("createRelease.deployHint", { id: existing.id }))}`, { release: existing, reused: true });
+            const releases = await listReleases(context.np, app.id, { limit: 25 }).catch(() => [existing]);
+            return reply(`${glyph("active")} ${translate("createRelease.exists", { semver: existing.semver, build: buildId })}${next(translate("createRelease.deployHint", { id: existing.id }))}`, { release: existing, reused: true, app: `#${app.id}`, app_name: app.name, releases });
         }
         const release = await createRelease(context.np, {
             application_id: app.id,
             build_id: buildId,
             semver: args.semver,
         });
-        return reply(`${glyph("active")} ${translate("createRelease.done", { semver: release.semver, from: buildNote })}${next(translate("createRelease.deployHint", { id: release.id }))}`, { release, reused: false });
+        // Mirror the releases widget's shape so the SAME panel renders the new release with its
+        // Deploy action (read-after-write); the markdown stays the plain confirmation.
+        const releases = await listReleases(context.np, app.id, { limit: 25 }).catch(() => [release]);
+        return reply(`${glyph("active")} ${translate("createRelease.done", { semver: release.semver, from: buildNote })}${next(translate("createRelease.deployHint", { id: release.id }))}`, { release, reused: false, app: `#${app.id}`, app_name: app.name, releases });
     },
 });

package/dist/tools/create-scope.js

@@ -5,11 +5,14 @@ import { createScope, listScopes, listScopeTypes } from "../np/journey.js";
 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";
 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. This provisions real infrastructure asynchronously. If the org has several scope types and none is given, it lists them to pick from.",
-    annotations: { destructiveHint: false, openWorldHint: true },
+    // Convergent under retries (reuses the scope-by-name), so idempotent.
+    annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    widget: "np-panel",
     errorKey: "createScope.errorLabel",
     inputSchema: {
         app: appArg,
@@ -31,10 +34,13 @@ export const createScopeTool = defineTool({
         const siblings = await listScopes(context.np, app.id);
         const existing = siblings.find((scope) => scope.name.toLowerCase() === args.name.toLowerCase());
         if (existing) {
-            const orgSlug = await context.org.organizationSlug();
+            const [orgSlug, status] = await Promise.all([
+                context.org.organizationSlug(),
+                buildAppStatus(context, app),
+            ]);
             return reply(translate("createScope.exists", { name: existing.name, id: existing.id, status: existing.status }) +
                 next(translate("createScope.provisioningHint", { name: existing.name })) +
-                linkLine(translate("md.dashboard"), dashboardLink(orgSlug, existing.nrn)), { scope: existing, reused: true });
+                linkLine(translate("md.dashboard"), dashboardLink(orgSlug, existing.nrn)), { ...status.structured, scope: existing, reused: true });
         }
         let type = args.type;
         let provider = args.provider;
@@ -46,11 +52,14 @@ export const createScopeTool = defineTool({
                 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 }))}`, { scope_types: scopeTypes });
+                ]))}${next(translate("createScope.typeHint", { name: args.name }))}`, { ...structured, scope_types: scopeTypes });
             }
         }
         if (!type)
@@ -69,7 +78,12 @@ export const createScopeTool = defineTool({
             provider,
             dimensions,
         });
-        const orgSlug = await context.org.organizationSlug();
+        // Hand off into np-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(),
+            buildAppStatus(context, app),
+        ]);
         return reply(translate("createScope.provisioning", {
             name: scope.name,
             id: scope.id,
@@ -77,6 +91,6 @@ export const createScopeTool = defineTool({
             dimensions: dimensions ? `, ${dimsLabel(dimensions)}` : "",
         }) +
             next(translate("createScope.provisioningHint", { name: scope.name })) +
-            linkLine(translate("md.dashboard"), dashboardLink(orgSlug, scope.nrn)), { scope });
+            linkLine(translate("md.dashboard"), dashboardLink(orgSlug, scope.nrn)), { ...status.structured, scope, reused: false });
     },
 });

package/dist/tools/deployments.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { translate } from "../i18n.js";
+import { ago, glyph, next, table } from "../md.js";
+import { isDeploymentTerminal, listDeployments, listReleases, listScopes, } from "../np/journey.js";
+import { defineTool, reply } from "../tool.js";
+import { TOOL } from "../tool-names.js";
+import { appArg, offsetArg, pageOf, requireApp } from "./shared.js";
+/**
+ * The deployments list — the end of build → release → deploy. Lists every deployment across an
+ * app's scopes (a deployment_group lands one release on several scopes and is shown as one row),
+ * resolving scope and release names so both the text reply and the bound widget read cleanly.
+ */
+export const deploymentsTool = defineTool({
+    name: TOOL.applicationDeploymentList,
+    title: "Deployments",
+    description: "List an application's deployments across all scopes — which release landed on which scope, the rollout status, and age; a deployment group (one release to several scopes) is shown as one row. Use to see deploy history or find an active rollout.",
+    annotations: { readOnlyHint: true, openWorldHint: true },
+    widget: "deployments",
+    errorKey: "deploymentList.errorLabel",
+    inputSchema: {
+        app: appArg,
+        limit: z.number().optional().describe("How many recent deployments (default 50)"),
+        offset: offsetArg,
+    },
+    async handler(args, context) {
+        const resolved = await requireApp(context, args);
+        if ("out" in resolved)
+            return resolved.out;
+        const app = resolved.app;
+        const [rows, scopes, releases] = await Promise.all([
+            listDeployments(context.np, app.id, { limit: args.limit ?? 50, offset: args.offset }),
+            listScopes(context.np, app.id),
+            listReleases(context.np, app.id, { limit: 200 }),
+        ]);
+        if (rows.length === 0) {
+            return reply(translate("deploymentList.none", { app: app.name }), {
+                app: `#${app.id}`,
+                app_name: app.name,
+                deployments: [],
+            });
+        }
+        const scopeName = new Map(scopes.map((scope) => [scope.id, scope.name]));
+        const semverOf = new Map(releases.map((release) => [release.id, release.semver]));
+        const scopeLabel = (row) => row.type === "deployment_group"
+            ? translate("deploymentList.group", { count: row.deployments?.length ?? 0 })
+            : (scopeName.get(row.scope_id ?? -1) ?? `scope #${row.scope_id ?? "?"}`);
+        const releaseLabel = (releaseId) => releaseId ? (semverOf.get(releaseId) ?? `#${releaseId}`) : "";
+        // A group has no status of its own — derive a headline from its children (same precedence as
+        // the widget's collapsed row), so the text reply never prints "· undefined".
+        const statusOf = (row) => {
+            if (row.type !== "deployment_group")
+                return row.status;
+            const children = row.deployments ?? [];
+            if (children.some((child) => !isDeploymentTerminal(child.status)))
+                return "running";
+            if (children.some((child) => child.status === "failed" || child.status === "rolled_back"))
+                return "failed";
+            if (children.length && children.every((child) => child.status === "finalized"))
+                return "finalized";
+            return children[0]?.status ?? "pending";
+        };
+        const markdown = [
+            translate("deploymentList.title", { app: app.name, count: rows.length }),
+            "",
+            table([
+                translate("header.scope"),
+                translate("header.release"),
+                translate("header.status"),
+                translate("header.when"),
+            ], rows.map((row) => [
+                scopeLabel(row),
+                releaseLabel(row.release_id),
+                `${glyph(statusOf(row))} ${statusOf(row)}`,
+                ago(row.created_at),
+            ])),
+            next(translate("deploymentList.hint")),
+        ].join("\n");
+        // Enrich the structured rows the widget renders: scope + release names resolved, children too.
+        const enrich = (row) => ({
+            ...row,
+            scope_name: scopeName.get(row.scope_id ?? -1) ?? null,
+            release_semver: row.release_id ? (semverOf.get(row.release_id) ?? null) : null,
+        });
+        const deployments = rows.map((row) => ({
+            ...enrich(row),
+            deployments: row.deployments?.map(enrich),
+        }));
+        return reply(markdown, {
+            app: `#${app.id}`,
+            app_name: app.name,
+            deployments,
+            page: pageOf(rows.length, args.limit ?? 50, args.offset ?? 0),
+        });
+    },
+});

package/dist/tools/index.js

@@ -4,12 +4,14 @@ import { createAppTool } from "./create-app.js";
 import { createReleaseTool } from "./create-release.js";
 import { createScopeTool } from "./create-scope.js";
 import { deployTool } from "./deploy.js";
+import { deploymentsTool } from "./deployments.js";
 import { findAppsTool } from "./find-apps.js";
 import { logsTool } from "./logs.js";
 import { metricsTool } from "./metrics.js";
 import { overviewTool } from "./overview.js";
 import { paramsTool } from "./params.js";
 import { playbookGetTool } from "./playbook.js";
+import { releasesTool } from "./releases.js";
 import { servicesTool } from "./services.js";
 import { setParamsTool } from "./set-params.js";
 import { statusTool } from "./status.js";
@@ -24,6 +26,8 @@ export const tools = [
     overviewTool,
     findAppsTool,
     buildsTool,
+    releasesTool,
+    deploymentsTool,
     logsTool,
     paramsTool,
     metricsTool,

package/dist/tools/logs.js

@@ -22,6 +22,10 @@ export const logsTool = defineTool({
             .optional()
             .describe("ISO-8601 start of the time window, e.g. 2026-06-13T10:00:00Z"),
         end_time: z.string().optional().describe("ISO-8601 end of the time window (defaults to now)"),
+        page_token: z
+            .string()
+            .optional()
+            .describe("Pagination cursor (the next_page_token from a prior call) to fetch the next page of older lines."),
     },
     async handler(args, context) {
         const resolved = await requireApp(context, args);
@@ -45,6 +49,7 @@ export const logsTool = defineTool({
         const page = await readLogs(context.np, {
             application_id: app.id,
             scope_id: scope.id,
+            next_page_token: args.page_token,
             start_time: args.start_time,
             end_time: args.end_time,
         });

package/dist/tools/overview.js

@@ -16,6 +16,7 @@ export const overviewTool = defineTool({
     title: "Organization overview",
     description: "A cross-application health digest for the whole org: what's mid-rollout right now, and which scopes' last deployment failed or rolled back. Answers 'is anything broken?' / 'what's deploying?' without naming an app. Scans up to the first ~30 applications.",
     annotations: { readOnlyHint: true, openWorldHint: true },
+    widget: "overview",
     errorKey: "overview.errorLabel",
     inputSchema: {
         query: z.string().optional().describe("Limit the scan to apps whose name contains this"),
@@ -36,6 +37,7 @@ export const overviewTool = defineTool({
                 if (!isDeploymentTerminal(latest.status)) {
                     active.push({
                         app: app.name,
+                        app_id: app.id,
                         scope: scope.name,
                         deployment_id: latest.id,
                         status: latest.status,
@@ -46,6 +48,7 @@ export const overviewTool = defineTool({
                 else if (latest.status === "failed" || latest.status === "rolled_back") {
                     trouble.push({
                         app: app.name,
+                        app_id: app.id,
                         scope: scope.name,
                         status: latest.status,
                         when: latest.created_at,

package/dist/tools/params.js

@@ -3,7 +3,7 @@ import { dashboardLink, linkLine, next, table } from "../md.js";
 import { listParameters } from "../np/journey.js";
 import { defineTool, fail, reply } from "../tool.js";
 import { TOOL } from "../tool-names.js";
-import { appArg, requireApp } from "./shared.js";
+import { appArg, offsetArg, pageOf, requireApp } from "./shared.js";
 export const paramsTool = defineTool({
     name: TOOL.applicationParameterList,
     title: "Parameters",
@@ -11,7 +11,7 @@ export const paramsTool = defineTool({
     annotations: { readOnlyHint: true, openWorldHint: true },
     widget: "params",
     errorKey: "params.errorLabel",
-    inputSchema: { app: appArg },
+    inputSchema: { app: appArg, offset: offsetArg },
     async handler(args, context) {
         const resolved = await requireApp(context, args);
         if ("out" in resolved)
@@ -20,7 +20,7 @@ export const paramsTool = defineTool({
         if (!app.nrn)
             return fail(translate("resolve.noNrn", { app: app.name }));
         const [parameters, orgSlug] = await Promise.all([
-            listParameters(context.np, app.nrn),
+            listParameters(context.np, app.nrn, { offset: args.offset }),
             context.org.organizationSlug(),
         ]);
         const dashboard = dashboardLink(orgSlug, app.nrn);
@@ -53,6 +53,11 @@ export const paramsTool = defineTool({
             ])),
             next(translate("params.applyHint")),
         ].join("\n");
-        return reply(markdown, { available: true, params: parameters, ...appRef });
+        return reply(markdown, {
+            available: true,
+            params: parameters,
+            page: pageOf(parameters.length, 100, args.offset ?? 0),
+            ...appRef,
+        });
     },
 });

package/dist/tools/playbook.js

@@ -16,6 +16,7 @@ export const playbookGetTool = defineTool({
     title: "Operating playbooks",
     description: "Read a nullplatform operating playbook — the methodology to follow BEFORE the matching non-trivial work (e.g. deploying-safely before a deploy, incident-response when something is broken, configuring-safely before changing parameters or secrets). The server instructions carry the full catalog; call this with no name to list them too.",
     annotations: { readOnlyHint: true },
+    widget: "playbook",
     errorKey: "playbook.errorLabel",
     inputSchema: {
         name: z.string().optional().describe('Playbook name, e.g. "deploying-safely". Omit to list them.'),

package/dist/tools/releases.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { translate } from "../i18n.js";
+import { ago, glyph, next, table } from "../md.js";
+import { listReleases } from "../np/journey.js";
+import { defineTool, reply } from "../tool.js";
+import { TOOL } from "../tool-names.js";
+import { appArg, offsetArg, pageOf, requireApp } from "./shared.js";
+/**
+ * The releases list — the middle of build → release → deploy. A release is an immutable semver
+ * pointer to a build; this lists them so the model (and the bound widget) can pick one to deploy.
+ */
+export const releasesTool = defineTool({
+    name: TOOL.applicationReleaseList,
+    title: "Releases",
+    description: "List an application's releases — semver, status (active/deprecated/unstable/failed), the build each pins, and age. Use to pick a release to deploy or promote, or to see what's shippable.",
+    annotations: { readOnlyHint: true, openWorldHint: true },
+    widget: "releases",
+    errorKey: "releaseList.errorLabel",
+    inputSchema: {
+        app: appArg,
+        limit: z.number().optional().describe("How many recent releases (default 25)"),
+        offset: offsetArg,
+    },
+    async handler(args, context) {
+        const resolved = await requireApp(context, args);
+        if ("out" in resolved)
+            return resolved.out;
+        const app = resolved.app;
+        const releases = await listReleases(context.np, app.id, {
+            limit: args.limit ?? 25,
+            offset: args.offset,
+        });
+        if (releases.length === 0) {
+            return reply(translate("releaseList.none", { app: app.name }) + next(translate("releaseList.noneHint")), { app: `#${app.id}`, app_name: app.name, releases: [] });
+        }
+        const markdown = [
+            translate("releaseList.title", { app: app.name, count: releases.length }),
+            "",
+            table([
+                translate("header.version"),
+                translate("header.status"),
+                translate("header.build"),
+                translate("header.when"),
+            ], releases.map((release) => [
+                release.semver,
+                `${glyph(release.status)} ${release.status}`,
+                release.build_id ? `#${release.build_id}` : "",
+                ago(release.created_at),
+            ])),
+            next(translate("releaseList.deployHint")),
+        ].join("\n");
+        return reply(markdown, {
+            app: `#${app.id}`,
+            app_name: app.name,
+            releases,
+            page: pageOf(releases.length, args.limit ?? 25, args.offset ?? 0),
+        });
+    },
+});

package/dist/tools/services.js

@@ -15,6 +15,7 @@ export const servicesTool = defineTool({
     title: "Services & dependencies",
     description: "List the dependency services (databases, queues, caches…) attached to an application, plus the catalog of dependency types available to provision. Read-only: provisioning a new dependency is a guided flow, so this links you into the dashboard to create one.",
     annotations: { readOnlyHint: true, openWorldHint: true },
+    widget: "services",
     errorKey: "services.errorLabel",
     inputSchema: { app: appArg },
     async handler(args, context) {
@@ -29,7 +30,8 @@ export const servicesTool = defineTool({
             listServiceSpecifications(context.bff, app.nrn),
             context.org.organizationSlug(),
         ]);
-        const dashboard = linkLine(translate("md.dashboard"), dashboardLink(orgSlug, app.nrn));
+        const dashboardUrl = dashboardLink(orgSlug, app.nrn);
+        const dashboard = linkLine(translate("md.dashboard"), dashboardUrl);
         const sections = [];
         if (services.length === 0) {
             sections.push(translate("services.none", { app: app.name }));
@@ -53,6 +55,7 @@ export const servicesTool = defineTool({
             app_name: app.name,
             services,
             catalog,
+            dashboard: dashboardUrl,
         });
     },
 });

package/dist/tools/set-params.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { translate } from "../i18n.js";
 import { next } from "../md.js";
-import { setParameters } from "../np/journey.js";
+import { listParameters, setParameters } from "../np/journey.js";
 import { defineTool, errorMessage, fail, reply } from "../tool.js";
 import { TOOL } from "../tool-names.js";
 import { appArg, requireApp } from "./shared.js";
@@ -9,7 +9,8 @@ export const setParamsTool = defineTool({
     name: TOOL.applicationParameterCreate,
     title: "Set parameters",
     description: "Create or update application configuration parameters (environment variables or files; mark secrets). Values apply on the NEXT deploy.",
-    annotations: { destructiveHint: false, openWorldHint: true },
+    annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    widget: "params",
     errorKey: "setParams.errorLabel",
     inputSchema: {
         app: appArg,
@@ -44,10 +45,16 @@ export const setParamsTool = defineTool({
                         app: app.name,
                         names,
                     });
+            // Mirror the params widget's shape so the SAME panel renders the resulting set with its
+            // add/save affordance (read-after-write); the markdown stays the plain confirmation.
+            const parameters = await listParameters(context.np, app.nrn).catch(() => undefined);
             return reply(summary + next(translate("setParams.applyHint")), {
                 created: result.created,
                 updated: result.updated,
                 total,
+                app: `#${app.id}`,
+                app_name: app.name,
+                ...(parameters === undefined ? { available: false } : { available: true, params: parameters }),
             });
         }
         catch (caught) {

package/dist/tools/shared.js

@@ -11,6 +11,19 @@ export const appArg = z
     .string()
     .optional()
     .describe('Application name or "#id". Omit it to use the app linked to the current repo (git remote).');
+export const offsetArg = z
+    .number()
+    .optional()
+    .describe("Skip this many items to page through a long list (use page.next_offset from a prior call).");
+/**
+ * Pagination token for a list reply. No list endpoint returns a total, so the boundary is the
+ * standard offset heuristic: a full page means there is likely more. The widget/model pages by
+ * re-calling the tool with `offset: next_offset` until `has_more` is false.
+ */
+export function pageOf(count, limit, offset = 0) {
+    const hasMore = count >= limit;
+    return { has_more: hasMore, next_offset: hasMore ? offset + limit : null };
+}
 export function httpsRepoUrl(url) {
     const trimmed = url.trim().replace(/\.git$/, "");
     const sshForm = /^git@([^:]+):(.+)$/.exec(trimmed);