@mcpcloud/cli 0.17.2 → 0.18.0

package/dist/index.js

@@ -5180,6 +5180,68 @@ async function resolveOrgId(orgId) {
   return first.id;
 }
 
+// src/lib/paginate.ts
+var MAX_PAGE_SIZE = 100;
+var MAX_PAGES = 200;
+async function fetchAllPages(path, params, key, options = {}) {
+  const items = [];
+  let cursor = null;
+  for (let page = 0;page < MAX_PAGES; page += 1) {
+    const remaining = options.max === undefined ? MAX_PAGE_SIZE : options.max - items.length;
+    if (remaining <= 0)
+      break;
+    const data = await api.get(path, {
+      ...params,
+      limit: String(Math.min(MAX_PAGE_SIZE, remaining)),
+      ...cursor ? { cursor } : {}
+    });
+    const rows = data[key];
+    if (Array.isArray(rows))
+      items.push(...rows);
+    const next = typeof data.nextCursor === "string" ? data.nextCursor : null;
+    if (data.hasMore !== true || !next)
+      break;
+    cursor = next;
+  }
+  return options.max === undefined ? items : items.slice(0, options.max);
+}
+async function fetchAllPagesWithEnvelope(path, params, key, options = {}) {
+  let envelope = {};
+  let captured = false;
+  const rows = [];
+  let cursor = null;
+  for (let page = 0;page < MAX_PAGES; page += 1) {
+    const remaining = options.max === undefined ? MAX_PAGE_SIZE : options.max - rows.length;
+    if (remaining <= 0)
+      break;
+    const data = await api.get(path, {
+      ...params,
+      limit: String(Math.min(MAX_PAGE_SIZE, remaining)),
+      ...cursor ? { cursor } : {}
+    });
+    if (!captured) {
+      const { nextCursor: _n, hasMore: _h, ...rest } = data;
+      envelope = rest;
+      captured = true;
+    }
+    const pageRows = data[key];
+    if (Array.isArray(pageRows))
+      rows.push(...pageRows);
+    const next = typeof data.nextCursor === "string" ? data.nextCursor : null;
+    if (data.hasMore !== true || !next)
+      break;
+    cursor = next;
+  }
+  const capped = options.max === undefined ? rows : rows.slice(0, options.max);
+  return { rows: capped, payload: { ...envelope, [key]: capped } };
+}
+function parseRowCap(raw) {
+  if (raw === undefined)
+    return;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 // src/lib/resolve-match.ts
 var ID_SHAPE = /^[a-z0-9]{32}$/;
 function isIdShape(ref) {
@@ -5392,25 +5454,21 @@ async function probeById(spec, scope, id) {
   });
 }
 function candidateSlug(kind, row) {
+  if (typeof row.slug === "string" && row.slug.trim()) {
+    return row.slug.trim().toLowerCase();
+  }
   if (kind === "server") {
     return deriveServerSlug(typeof row.deploymentUrl === "string" ? row.deploymentUrl : undefined);
   }
-  if (kind === "project" && typeof row.slug === "string" && row.slug.trim()) {
-    return row.slug.trim().toLowerCase();
-  }
   return;
 }
 async function loadCandidates(kind, spec, scope) {
   const params = {
-    organizationId: scope.organizationId,
-    limit: "100"
+    organizationId: scope.organizationId
   };
   if (scope.projectId && kind !== "project")
     params["projectId"] = scope.projectId;
-  const data = await api.get(spec.listPath, params);
-  const rows = data?.[spec.listKey];
-  if (!Array.isArray(rows))
-    return [];
+  const rows = await fetchAllPages(spec.listPath, params, spec.listKey);
   return rows.filter((row) => typeof row?.id === "string").map((row) => ({
     id: row.id,
     name: typeof row.name === "string" ? row.name : "",
@@ -6245,11 +6303,8 @@ function registerProjectCommands(program2) {
   ].join(`
 `)).action(runAction(async (opts) => {
     const orgId = await resolveOrgId(opts.org);
-    const data = await api.get("/api/v1/projects", {
-      organizationId: orgId,
-      limit: opts.limit
-    });
-    printList(data.projects.map((p2) => ({
+    const { rows: projectRows, payload } = await fetchAllPagesWithEnvelope("/api/v1/projects", { organizationId: orgId }, "projects", { max: parseRowCap(opts.limit) });
+    printList(projectRows.map((p2) => ({
       id: p2.id,
       name: p2.name,
       slug: p2.slug,
@@ -6261,7 +6316,7 @@ function registerProjectCommands(program2) {
       { key: "slug", label: "Slug", width: 20 },
       { key: "servers", label: "Servers", width: 8 },
       { key: "created", label: "Created", width: 20 }
-    ], data);
+    ], payload);
   }));
   projects.command("get <project>").description("Get details for a single project (accepts id or name)").option("--org <organizationId>", "Organization ID").action(runAction(async (projectRef, opts) => {
     const orgId = await resolveOrgId(opts.org);
@@ -6634,8 +6689,483 @@ async function tailDeploymentLogs(args) {
   }
 }
 
+// src/commands/servers-deps.ts
+var DEPS_PATH = "/api/v1/server/dependencies";
+function reportApiError(err, action) {
+  if (err instanceof McpCloudApiError) {
+    printError(`${action} failed (HTTP ${err.status}): ${err.error.message}`);
+    const reason = err.error.details?.reason;
+    if (typeof reason === "string") {
+      printInfo(`  ${c.dim("reason:")} ${reason}`);
+    }
+  } else {
+    printError(`${action} failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  throw new CliExitError(1);
+}
+function printDependencies(deps) {
+  if (deps.length === 0) {
+    printInfo(c.dim("  No dependencies. Add one with `mcp servers deps add`."));
+    return;
+  }
+  printList(deps.map((dep) => ({
+    id: dep.id,
+    child: dep.childName ?? dep.childServerId ?? "—",
+    prefix: dep.toolPrefix,
+    tools: dep.includedTools ? dep.includedTools.join(", ") : "all",
+    enabled: dep.enabled ? "yes" : "no"
+  })), [
+    { key: "id", label: "ID", width: 34 },
+    { key: "child", label: "Child", width: 26 },
+    { key: "prefix", label: "Prefix", width: 16 },
+    { key: "tools", label: "Tools", width: 28 },
+    { key: "enabled", label: "Enabled", width: 8 }
+  ], { dependencies: deps });
+}
+function registerServerDepsCommands(servers) {
+  const deps = servers.command("deps").description("Compose another server's tools into this one (list / add / rm)");
+  deps.command("list [server]").description("List the servers this one composes.").option("--org <organizationId>", "Organization ID").action(runAction(async (server, opts) => {
+    const orgId = await resolveOrgId(opts.org);
+    const serverId = await resolveServerId(requireServer(server), orgId);
+    try {
+      const data = await api.get(DEPS_PATH, {
+        organizationId: orgId,
+        serverId
+      });
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      printDependencies(data.dependencies);
+    } catch (err) {
+      reportApiError(err, "Listing dependencies");
+    }
+  }));
+  deps.command("add <server> <child>").description("Compose <child>'s tools into <server>. Both accept an id, name or slug.").option("--org <organizationId>", "Organization ID").option("--prefix <prefix>", "Prefix for the re-exposed tool names (defaults to the child's slug).").option("--tools <names>", "Comma-separated child tool names to expose; omit for all of them.").addHelpText("after", [
+    "",
+    "Examples:",
+    "  $ mcp servers deps add my-api billing-api",
+    "  $ mcp servers deps add my-api billing-api --prefix billing_",
+    "  $ mcp servers deps add my-api billing-api --tools getCharges,createRefund"
+  ].join(`
+`)).action(runAction(async (server, child, opts) => {
+    const orgId = await resolveOrgId(opts.org);
+    const serverId = await resolveServerId(server, orgId);
+    const childServerId = await resolveServerId(child, orgId);
+    const includedTools = (opts.tools ?? "").split(",").map((name) => name.trim()).filter(Boolean);
+    try {
+      const data = await api.post(DEPS_PATH, {
+        organizationId: orgId,
+        serverId,
+        childServerId,
+        ...opts.prefix ? { toolPrefix: opts.prefix } : {},
+        ...includedTools.length > 0 ? { includedTools } : {}
+      });
+      if (isJsonMode()) {
+        printJson({ ok: true, ...data });
+        return;
+      }
+      const dep = data.dependency;
+      printSuccess(`Composed ${c.bold(dep.childName ?? child)} into ${c.bold(server)} ${c.dim(`(prefix ${dep.toolPrefix})`)}`);
+      printInfo(`  ${c.dim("Its tools appear on the parent as")} ${c.bold(`${dep.toolPrefix}<tool>`)} ${c.dim("after the next policy sync — no redeploy needed.")}`);
+    } catch (err) {
+      reportApiError(err, "Binding the dependency");
+    }
+  }));
+  deps.command("rm <server> <dependencyId>").description("Remove a composed dependency (id from `deps list`).").option("--org <organizationId>", "Organization ID").action(runAction(async (server, dependencyId, opts) => {
+    const orgId = await resolveOrgId(opts.org);
+    const serverId = await resolveServerId(server, orgId);
+    try {
+      const data = await api.delete(`${DEPS_PATH}?organizationId=${encodeURIComponent(orgId)}&serverId=${encodeURIComponent(serverId)}&dependencyId=${encodeURIComponent(dependencyId)}`);
+      if (isJsonMode()) {
+        printJson({ ok: true, ...data });
+        return;
+      }
+      printSuccess(`Removed ${c.bold(data.removed.childName ?? data.removed.id)} ${c.dim(`(prefix ${data.removed.toolPrefix})`)}`);
+    } catch (err) {
+      reportApiError(err, "Removing the dependency");
+    }
+  }));
+}
+function requireServer(server) {
+  if (server)
+    return server;
+  printError("Name the server whose dependencies you want to list.");
+  throw new CliExitError(1);
+}
+
+// src/commands/servers-prompts.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+
+// src/lib/server-scope.ts
+async function resolveServerScope(serverRef, org) {
+  const organizationId = await resolveOrgId(org);
+  const serverId = await resolveServerId(serverRef, organizationId);
+  const detail = await api.get("/api/v1/server", {
+    organizationId,
+    serverId
+  });
+  return {
+    organizationId,
+    projectId: detail.server.projectId,
+    serverId,
+    serverName: detail.server.name
+  };
+}
+
+// src/commands/servers-prompts.ts
+var PROMPT_PATH = "/api/v1/server/prompt";
+function reportApiError2(err, action) {
+  if (err instanceof McpCloudApiError) {
+    printError(`${action} failed (HTTP ${err.status}): ${err.error.message}`);
+    const details = err.error.details;
+    if (typeof details?.field === "string") {
+      printInfo(`  ${c.dim("field:")} ${details.field}`);
+    }
+  } else {
+    printError(`${action} failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  throw new CliExitError(1);
+}
+function countArguments(argumentsJson) {
+  try {
+    const parsed = JSON.parse(argumentsJson || "[]");
+    return Array.isArray(parsed) ? String(parsed.length) : "?";
+  } catch {
+    return "?";
+  }
+}
+function readTemplate(opts) {
+  if (opts.templateFile)
+    return readFileSync3(opts.templateFile, "utf8");
+  if (opts.template !== undefined)
+    return opts.template;
+  printError("A template is required — pass --template <markdown> or --template-file <path>.");
+  throw new CliExitError(1);
+}
+function registerServerPromptCommands(servers) {
+  const prompts = servers.command("prompts").description("Author the prompts a client reads as this server’s workflows (list / set / rm)");
+  prompts.command("list <server>").description("List the prompts authored on a server.").option("--org <organizationId>", "Organization ID").action(runAction(async (server, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    try {
+      const data = await api.get(PROMPT_PATH, {
+        organizationId: scope.organizationId,
+        projectId: scope.projectId,
+        serverId: scope.serverId
+      });
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      if (data.prompts.length === 0) {
+        printInfo(c.dim("  No prompts. Add one with `mcp servers prompts set`."));
+        return;
+      }
+      printList(data.prompts.map((prompt2) => ({
+        name: prompt2.name,
+        args: countArguments(prompt2.argumentsJson),
+        description: prompt2.description ?? "—"
+      })), [
+        { key: "name", label: "NAME", width: 28 },
+        { key: "args", label: "ARGS", width: 6 },
+        { key: "description", label: "DESCRIPTION", width: 48 }
+      ]);
+    } catch (err) {
+      reportApiError2(err, "Listing prompts");
+    }
+  }));
+  prompts.command("set <server> <name>").description("Create or replace a prompt by name. Re-running with the same name updates it.").option("--org <organizationId>", "Organization ID").option("--template <markdown>", "Prompt body, inline").option("--template-file <path>", "Prompt body, read from a file").option("--arguments <json>", "JSON array of {name, description, required}; defaults to []").option("--description <text>", "What the prompt is for").addHelpText("after", [
+    "",
+    "Examples:",
+    "  $ mcp servers prompts set my-api triage --template-file ./triage.md",
+    `  $ mcp servers prompts set my-api triage --template 'Summarize {{issue}}.' \\`,
+    `      --arguments '[{"name":"issue","required":true}]'`,
+    "",
+    "Notes:",
+    "  --arguments is validated strictly. A placeholder in the template that",
+    "  is not a declared argument is reported, not refused — clients cannot",
+    "  fill those in."
+  ].join(`
+`)).action(runAction(async (server, name, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    const templateMarkdown = readTemplate(opts);
+    try {
+      const data = await api.put(PROMPT_PATH, {
+        argumentsJson: opts.arguments ?? "[]",
+        description: opts.description ?? null,
+        name,
+        organizationId: scope.organizationId,
+        projectId: scope.projectId,
+        serverId: scope.serverId,
+        templateMarkdown
+      });
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      printSuccess(`${data.prompt.replaced ? "Updated" : "Created"} prompt ${c.bold(name)} on ${scope.serverName}.`);
+      for (const notice of data.notices ?? []) {
+        printWarn(notice.message);
+      }
+      printInfo(c.dim("  Not live yet: run `mcp servers generate <server> --store`, then deploy."));
+    } catch (err) {
+      reportApiError2(err, "Saving the prompt");
+    }
+  }));
+  prompts.command("rm <server> <name>").description("Remove a prompt by name.").option("--org <organizationId>", "Organization ID").action(runAction(async (server, name, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    try {
+      const data = await api.delete(`${PROMPT_PATH}?organizationId=${encodeURIComponent(scope.organizationId)}&projectId=${encodeURIComponent(scope.projectId)}&serverId=${encodeURIComponent(scope.serverId)}&name=${encodeURIComponent(name)}`);
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      printSuccess(`Removed prompt ${c.bold(name)}.`);
+    } catch (err) {
+      reportApiError2(err, "Removing the prompt");
+    }
+  }));
+}
+
+// src/commands/servers-resources.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+var RESOURCE_PATH = "/api/v1/server/resource";
+function reportApiError3(err, action) {
+  if (err instanceof McpCloudApiError) {
+    printError(`${action} failed (HTTP ${err.status}): ${err.error.message}`);
+  } else {
+    printError(`${action} failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  throw new CliExitError(1);
+}
+function registerServerResourceCommands(servers) {
+  const resources = servers.command("resources").description("Author the resources this server exposes to clients (list / set / rm)");
+  resources.command("list <server>").description("List the resources authored on a server.").option("--org <organizationId>", "Organization ID").action(runAction(async (server, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    try {
+      const data = await api.get(RESOURCE_PATH, {
+        organizationId: scope.organizationId,
+        projectId: scope.projectId,
+        serverId: scope.serverId
+      });
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      if (data.resources.length === 0) {
+        printInfo(c.dim("  No resources. Add one with `mcp servers resources set`."));
+        return;
+      }
+      printList(data.resources.map((resource) => ({
+        uri: resource.uri,
+        name: resource.name,
+        type: resource.resourceType,
+        mime: resource.mimeType
+      })), [
+        { key: "uri", label: "URI", width: 40 },
+        { key: "name", label: "NAME", width: 24 },
+        { key: "type", label: "TYPE", width: 9 },
+        { key: "mime", label: "MIME", width: 20 }
+      ]);
+    } catch (err) {
+      reportApiError3(err, "Listing resources");
+    }
+  }));
+  resources.command("set <server> <uri>").description("Create or replace a resource by URI. Re-running with the same URI updates it.").option("--org <organizationId>", "Organization ID").option("--name <name>", "Human-readable name (defaults to the URI)").option("--description <text>", "What the resource holds").option("--mime <type>", "MIME type", "text/markdown").option("--content <text>", "Body of a static resource, inline").option("--content-file <path>", "Body of a static resource, from a file").option("--upstream <template>", "Upstream path template — makes this a DYNAMIC resource fetched per read").addHelpText("after", [
+    "",
+    "Examples:",
+    "  $ mcp servers resources set my-api docs://api/limits --content-file ./limits.md",
+    "  $ mcp servers resources set my-api docs://api/status --upstream /status",
+    "",
+    "Notes:",
+    "  A resource is static (a body you supply) or dynamic (fetched from the",
+    "  upstream on each read). Passing --upstream makes it dynamic; otherwise",
+    "  content is required."
+  ].join(`
+`)).action(runAction(async (server, uri, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    const staticContent = opts.contentFile ? readFileSync4(opts.contentFile, "utf8") : opts.content ?? null;
+    const resourceType = opts.upstream ? "dynamic" : "static";
+    if (resourceType === "static" && !staticContent?.trim()) {
+      printError("A static resource needs a body — pass --content or --content-file, or --upstream to make it dynamic.");
+      throw new CliExitError(1);
+    }
+    try {
+      const data = await api.put(RESOURCE_PATH, {
+        description: opts.description ?? null,
+        mimeType: opts.mime ?? "text/markdown",
+        name: opts.name ?? uri,
+        organizationId: scope.organizationId,
+        projectId: scope.projectId,
+        resourceType,
+        serverId: scope.serverId,
+        staticContent,
+        upstreamPathTemplate: opts.upstream ?? null,
+        uri
+      });
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      printSuccess(`${data.resource.replaced ? "Updated" : "Created"} ${resourceType} resource ${c.bold(uri)} on ${scope.serverName}.`);
+      printInfo(c.dim("  Not live yet: run `mcp servers generate <server> --store`, then deploy."));
+    } catch (err) {
+      reportApiError3(err, "Saving the resource");
+    }
+  }));
+  resources.command("rm <server> <uri>").description("Remove a resource by URI.").option("--org <organizationId>", "Organization ID").action(runAction(async (server, uri, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    try {
+      const data = await api.delete(`${RESOURCE_PATH}?organizationId=${encodeURIComponent(scope.organizationId)}&projectId=${encodeURIComponent(scope.projectId)}&serverId=${encodeURIComponent(scope.serverId)}&uri=${encodeURIComponent(uri)}`);
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      printSuccess(`Removed resource ${c.bold(uri)}.`);
+    } catch (err) {
+      reportApiError3(err, "Removing the resource");
+    }
+  }));
+}
+
+// src/commands/servers-shape.ts
+var SCORE_PATH = "/api/v1/server/usability-score";
+var SHAPE_PATH = "/api/v1/server/shape";
+function reportApiError4(err, action) {
+  if (err instanceof McpCloudApiError) {
+    printError(`${action} failed (HTTP ${err.status}): ${err.error.message}`);
+  } else {
+    printError(`${action} failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  throw new CliExitError(1);
+}
+function formatPercent(value) {
+  return typeof value === "number" ? `${Math.round(value * 100)}%` : "—";
+}
+function registerServerShapingCommands(servers) {
+  servers.command("score <server>").description("Score whether an agent handed this catalog picks the right tool (starts a run, or reads the last one)").option("--org <organizationId>", "Organization ID").option("--start", "Start a new scoring run instead of reading the last").option("--runs <count>", "Runs to average, 2-5 (default 3)").addHelpText("after", [
+    "",
+    "Examples:",
+    "  $ mcp servers score my-api            # read the last score",
+    "  $ mcp servers score my-api --start    # start a new run",
+    "",
+    "Notes:",
+    "  A score is reported WITH its spread across runs. A move smaller than",
+    "  the spread is noise, not an improvement.",
+    "  Starting a run makes one model call per scenario per run and returns",
+    "  immediately; read the result with the same command."
+  ].join(`
+`)).action(runAction(async (server, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    const query = {
+      organizationId: scope.organizationId,
+      projectId: scope.projectId,
+      serverId: scope.serverId
+    };
+    if (opts.start) {
+      try {
+        const data = await api.post(SCORE_PATH, {
+          ...query,
+          ...opts.runs ? { runCount: Number(opts.runs) } : {}
+        });
+        if (isJsonMode()) {
+          printJson(data);
+          return;
+        }
+        printSuccess(`Scoring started for ${scope.serverName}.`);
+        printInfo(c.dim(`  ${data.message}`));
+      } catch (err) {
+        reportApiError4(err, "Starting the scoring run");
+      }
+      return;
+    }
+    try {
+      const data = await api.get(SCORE_PATH, query);
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      if (data.batch.length === 0) {
+        printInfo(c.dim("  Not measured yet. Run `mcp servers score <server> --start`."));
+        return;
+      }
+      const accuracies = data.batch.map((run) => run.accuracy).filter((value) => value !== null);
+      const min = Math.min(...accuracies);
+      const max = Math.max(...accuracies);
+      const mean = accuracies.reduce((sum, value) => sum + value, 0) / accuracies.length;
+      printSuccess(`${formatPercent(mean)} ±${formatPercent(max - min)} across ${data.batch.length} runs`);
+      printInfo(c.dim(`  ${data.batch[0]?.scored ?? 0} scenarios · ${data.catalogSize ?? "—"} tools · judged by ${data.modelKey ?? "—"}`));
+    } catch (err) {
+      reportApiError4(err, "Reading the score");
+    }
+  }));
+  servers.command("shape <server>").description("Propose task-shaped tools over this server’s endpoints (starts a run, or reads the last one)").option("--org <organizationId>", "Organization ID").option("--start", "Start a new shaping run instead of reading the last").addHelpText("after", [
+    "",
+    "Examples:",
+    "  $ mcp servers shape my-api --start    # propose task tools",
+    "  $ mcp servers shape my-api            # read the proposals",
+    "",
+    "Notes:",
+    "  Proposals are inspectable artifacts. Nothing is created until a",
+    "  proposal is accepted in the dashboard."
+  ].join(`
+`)).action(runAction(async (server, opts) => {
+    const scope = await resolveServerScope(server, opts.org);
+    const query = {
+      organizationId: scope.organizationId,
+      projectId: scope.projectId,
+      serverId: scope.serverId
+    };
+    if (opts.start) {
+      try {
+        const data = await api.post(SHAPE_PATH, query);
+        if (isJsonMode()) {
+          printJson(data);
+          return;
+        }
+        printSuccess(`Shaping started for ${scope.serverName}.`);
+        printInfo(c.dim(`  ${data.message}`));
+      } catch (err) {
+        reportApiError4(err, "Starting the shaping run");
+      }
+      return;
+    }
+    try {
+      const data = await api.get(SHAPE_PATH, query);
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      if (!data.run) {
+        printInfo(c.dim("  No shaping run yet. Run `mcp servers shape <server> --start`."));
+        return;
+      }
+      const reviewable = data.proposals.filter((p2) => !p2.rejectionReason);
+      const refused = data.proposals.filter((p2) => p2.rejectionReason);
+      printList(reviewable.map((proposal) => ({
+        name: proposal.name,
+        effect: proposal.effectClass ?? "—",
+        plan: JSON.parse(proposal.planJson).map((step) => step.operationName).join(" → ")
+      })), [
+        { key: "name", label: "PROPOSAL", width: 30 },
+        { key: "effect", label: "EFFECT", width: 16 },
+        { key: "plan", label: "PLAN", width: 46 }
+      ]);
+      if (refused.length > 0) {
+        printWarn(`${refused.length} proposal${refused.length === 1 ? "" : "s"} refused by validation: ${refused.map((p2) => p2.name).join(", ")}`);
+      }
+      if (data.run.failedClusterKeys.length > 0) {
+        printWarn(`${data.run.failedClusterKeys.length} endpoint group(s) produced nothing: ${data.run.failedClusterKeys.join(", ")}`);
+      }
+      printInfo(c.dim("  Accept a proposal in the dashboard; nothing is created here."));
+    } catch (err) {
+      reportApiError4(err, "Reading shaping proposals");
+    }
+  }));
+}
+
 // src/commands/servers-env.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
 import { resolve } from "node:path";
 function registerServerEnvCommands(servers) {
   const env = servers.command("env").description("Manage server runtime environment bindings (encrypted secrets injected by the proxy).");
@@ -6784,7 +7314,7 @@ async function resolveSetValue(args) {
       printError(`--from-file path not found: ${path}`);
       throw new CliExitError(1);
     }
-    return readFileSync3(path, "utf-8");
+    return readFileSync5(path, "utf-8");
   }
   return await readStdin();
 }
@@ -6940,7 +7470,7 @@ function registerServerSandboxVariableCommands(servers) {
 }
 
 // src/lib/mcp-invoke.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
 var DEFAULT_TIMEOUT_MS3 = 60000;
 var invokeRequestId = 1;
@@ -7160,7 +7690,7 @@ async function parseToolArguments(opts) {
     if (!existsSync4(filePath)) {
       return { ok: false, reason: "file-not-found", path: filePath };
     }
-    source = readFileSync4(filePath, "utf-8");
+    source = readFileSync6(filePath, "utf-8");
   } else {
     source = raw;
   }
@@ -7709,7 +8239,7 @@ function formatDeploymentExposure(deployment) {
 import { createHash as createHash2 } from "node:crypto";
 import {
   existsSync as existsSync5,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync7,
   watch as fsWatch
 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
@@ -7763,7 +8293,7 @@ function summarizeDiff(diff) {
 `) };
 }
 function readSpecFile(specPath) {
-  const content = readFileSync5(specPath, "utf-8");
+  const content = readFileSync7(specPath, "utf-8");
   return { content, hash: hashSpecContent(content) };
 }
 function watchSpecFile(options) {
@@ -7783,7 +8313,7 @@ function watchSpecFile(options) {
       return;
     let content;
     try {
-      content = readFileSync5(options.specPath, "utf-8");
+      content = readFileSync7(options.specPath, "utf-8");
     } catch {
       return;
     }
@@ -8418,7 +8948,7 @@ function registerServerMutationCommands(servers) {
 }
 
 // src/lib/spec-pipeline.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname4, join as join5, resolve as resolve5 } from "node:path";
 var SOURCE_TYPES = ["openapi", "graphql", "url"];
 function isHttpUrl(value) {
@@ -8451,7 +8981,7 @@ async function readSpecSource(spec, override, options = {}) {
     if (!existsSync7(filePath)) {
       throw new Error(`Spec file not found: ${filePath}`);
     }
-    content = readFileSync6(filePath, "utf-8");
+    content = readFileSync8(filePath, "utf-8");
     pathHint = filePath;
   }
   if (!content.trim()) {
@@ -8542,7 +9072,7 @@ function registerServerSpecCommands(servers) {
     });
     printStep(`Next: \`mcp servers generate ${data.server.id} --out ./out\` or \`mcp servers deploy ${data.server.id} --wait\`.`);
   }));
-  servers.command("generate <server>").description("Generate the server's TypeScript bundle (the exact code `deploy` ships) and optionally write it to disk — a dry-run for the codegen path. Wraps POST /api/v1/server/generate.").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; looked up from the server when omitted)").option("--out <dir>", "Write the generated files to this directory instead of just summarizing").addHelpText("after", [
+  servers.command("generate <server>").description("Generate the server's TypeScript bundle (the exact code `deploy` ships) and optionally write it to disk — a dry-run for the codegen path. Wraps POST /api/v1/server/generate.").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; looked up from the server when omitted)").option("--out <dir>", "Write the generated files to this directory instead of just summarizing").option("--store", "Persist the bundle as the one `deploy` will ship. Required after editing prompts, resources or tool metadata: deploy reuses a server's existing bundle unchanged, so without this the change never reaches the deployed worker.").addHelpText("after", [
     "",
     "Notes:",
     "  Codegen runs on the builder Worker (arch-evolution P7f). If generate",
@@ -8551,6 +9081,7 @@ function registerServerSpecCommands(servers) {
     "Examples:",
     "  $ mcp servers generate srv_123                 # summarize the bundle",
     "  $ mcp servers generate srv_123 --out ./build   # write files to disk",
+    "  $ mcp servers generate srv_123 --store         # make it the bundle deploy ships",
     "  $ mcp --json servers generate srv_123 | jq '.bundle.files[].path'"
   ].join(`
 `)).action(runAction(async (serverRef, opts) => {
@@ -8564,7 +9095,23 @@ function registerServerSpecCommands(servers) {
     if (!isJsonMode()) {
       printStep(`Generating bundle for ${c.bold(serverId)}…`);
     }
-    const data = await api.post("/api/v1/server/generate", { organizationId: orgId, projectId, serverId });
+    const data = await api.post("/api/v1/server/generate", {
+      organizationId: orgId,
+      projectId,
+      serverId,
+      ...opts.store ? { store: true } : {}
+    });
+    if (!isJsonMode() && data.storeHint) {
+      printWarn(data.storeHint);
+    }
+    if (!data.bundle) {
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      printSuccess(data.stored ? `Stored the bundle for ${c.bold(data.server.name)} — deploy now ships it.` : `Generated for ${c.bold(data.server.name)} (${data.generationStatus ?? "no files returned"}).`);
+      return;
+    }
     if (opts.out) {
       const written = writeBundleToDisk(data.bundle, opts.out);
       if (isJsonMode()) {
@@ -8599,7 +9146,7 @@ function registerServerSpecCommands(servers) {
 }
 
 // src/commands/servers-test-authoring.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 var EXECUTION_PROFILES = [
   "mockBindings",
   "previewBindings",
@@ -8617,9 +9164,9 @@ function parseTimeoutMs(value, fallbackMs) {
 }
 function readValueOption(raw) {
   if (raw === "@-")
-    return readFileSync7(0, "utf8");
+    return readFileSync9(0, "utf8");
   if (raw.startsWith("@"))
-    return readFileSync7(raw.slice(1), "utf8");
+    return readFileSync9(raw.slice(1), "utf8");
   return raw;
 }
 async function resolveServerAndProject(serverRef, org) {
@@ -8979,6 +9526,10 @@ function registerServerTestCommands(servers) {
 // src/commands/servers.ts
 function registerServerCommands(program2) {
   const servers = program2.command("servers").description("Manage MCP servers");
+  registerServerDepsCommands(servers);
+  registerServerPromptCommands(servers);
+  registerServerResourceCommands(servers);
+  registerServerShapingCommands(servers);
   registerServerEnvCommands(servers);
   registerServerSandboxVariableCommands(servers);
   registerServerGetCommand(servers);
@@ -8998,14 +9549,11 @@ function registerServerCommands(program2) {
 `)).action(runAction(async (opts) => {
     const orgId = await resolveOrgId(opts.org);
     const projectId = await resolveOptionalProjectId(opts.project, orgId);
-    const params = {
-      organizationId: orgId,
-      limit: opts.limit
-    };
+    const params = { organizationId: orgId };
     if (projectId)
       params["projectId"] = projectId;
-    const data = await api.get("/api/v1/servers", params);
-    printList(data.servers.map((s) => ({
+    const { rows: serverRows, payload } = await fetchAllPagesWithEnvelope("/api/v1/servers", params, "servers", { max: parseRowCap(opts.limit) });
+    printList(serverRows.map((s) => ({
       id: s.id,
       name: s.name,
       slug: deriveServerSlug(s.deploymentUrl) ?? "—",
@@ -9021,7 +9569,7 @@ function registerServerCommands(program2) {
       { key: "status", label: "Status", width: 10 },
       { key: "version", label: "Version", width: 8 },
       { key: "deployed", label: "Last Deployed", width: 22 }
-    ], data);
+    ], payload);
   }));
   servers.command("logs <server>").description("Show recent deployment events for a server's latest deployment").option("--org <organizationId>", "Organization ID").option("--limit <n>", "Number of recent events (default 50)", parsePositiveIntOption("limit"), "50").option("--follow", "Tail new events as they arrive (long-poll). Ctrl-C to stop.").option("--since <when>", "Only show events after this point. Accepts relative (5m, 1h, 30s), Unix-ms, or ISO-8601.").option("--follow-timeout <seconds>", "Maximum seconds to keep --follow open before exiting (default: 1 hour).", "3600").action(runAction(async (serverRef, opts) => {
     const orgId = await resolveOrgId(opts.org);
@@ -9150,14 +9698,14 @@ function registerServerCommands(program2) {
 }
 
 // src/commands/tools-diff.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
 import { relative } from "node:path";
 
 // src/lib/dev/handlers-sync.ts
 import {
   existsSync as existsSync10,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync12,
   statSync,
   writeFileSync as writeFileSync6
 } from "node:fs";
@@ -9165,7 +9713,7 @@ import { createHash as createHash3 } from "node:crypto";
 import { dirname as dirname5, join as join8 } from "node:path";
 
 // src/lib/dev/state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join6, resolve as resolve6 } from "node:path";
 function cachedStateMatchesTarget(cached2, target) {
   return cached2 !== null && cached2.serverId === target.serverId && cached2.organizationId === target.organizationId;
@@ -9194,7 +9742,7 @@ function readState(cwd) {
   if (!existsSync8(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync10(path, "utf-8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     const s = parsed;
@@ -9235,7 +9783,7 @@ function ensureGitignore(cwd) {
 import {
   existsSync as existsSync9,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync11,
   readdirSync,
   rmSync,
   writeFileSync as writeFileSync5
@@ -9449,7 +9997,7 @@ function readToolsState(devRootDir, serverId) {
   if (!existsSync9(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync9(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync11(file, "utf-8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     const s = parsed;
@@ -9529,7 +10077,7 @@ function readLocalTool(devRootDir, serverId, toolName) {
   const stateEntry = state?.tools[toolName];
   if (!stateEntry)
     return null;
-  const view = parseToolMarkdown(readFileSync9(filePath, "utf-8"));
+  const view = parseToolMarkdown(readFileSync11(filePath, "utf-8"));
   return {
     view,
     cloudId: stateEntry.id,
@@ -9592,6 +10140,7 @@ async function pushLocalToolEdit(args) {
       kind: "patched",
       updatedAt: result.tool.updatedAt,
       changedFields: result.patchedFields,
+      notices: result.notices ?? [],
       view: local.view
     };
   } catch (err) {
@@ -9622,11 +10171,8 @@ function toolNameFromWatcherPath(rel) {
   return rel.slice(0, -3);
 }
 async function fetchToolsForServer(args) {
-  const data = await api.get("/api/v1/project/tools", {
-    organizationId: args.organizationId,
-    projectId: args.projectId
-  });
-  return data.tools.filter((t) => t.serverId === args.serverId).map((t) => ({
+  const tools = await fetchAllPages("/api/v1/project/tools", { organizationId: args.organizationId, projectId: args.projectId }, "tools");
+  return tools.filter((t) => t.serverId === args.serverId).map((t) => ({
     id: t.id,
     serverId: t.serverId,
     name: t.name,
@@ -9680,7 +10226,7 @@ async function pushLocalHandlerEdit(args) {
   if (!resolved) {
     return { kind: "unknown-tool", slug: args.slug };
   }
-  const source = readFileSync10(filePath, "utf-8");
+  const source = readFileSync12(filePath, "utf-8");
   const hash = hashSource(source);
   if (lastPushedHash.get(filePath) === hash) {
     return { kind: "noop" };
@@ -9839,7 +10385,7 @@ function inspectLocalHandler(args) {
   if (!existsSync10(filePath))
     return { kind: "no-local-file" };
   const cached2 = lastPushedHash.get(filePath);
-  const onDisk = hashSource(readFileSync10(filePath, "utf-8"));
+  const onDisk = hashSource(readFileSync12(filePath, "utf-8"));
   if (cached2 !== undefined) {
     return cached2 === onDisk ? { kind: "matches-cache" } : { kind: "differs-from-cache" };
   }
@@ -9984,7 +10530,7 @@ function buildMetadataDiff(args) {
   let local = null;
   let parseError = null;
   try {
-    local = parseToolMarkdown(readFileSync11(filePath, "utf-8"));
+    local = parseToolMarkdown(readFileSync13(filePath, "utf-8"));
   } catch (err) {
     parseError = err instanceof Error ? err.message : String(err);
   }
@@ -10027,7 +10573,7 @@ async function buildHandlerDiff(args) {
   const slug = handlerSlugFromToolName(args.toolName);
   const filePath = `${serverBundleHandlersDir(args.devRootDir)}/${slug}.ts`;
   const hasLocal = existsSync11(filePath);
-  const localContent = hasLocal ? readFileSync11(filePath, "utf-8") : null;
+  const localContent = hasLocal ? readFileSync13(filePath, "utf-8") : null;
   const localPath = hasLocal ? relative(args.cwd, filePath) || filePath : null;
   const changed = hasLocal ? localContent !== cloudResult.snapshot.content : true;
   return {
@@ -10142,7 +10688,7 @@ import { join as join10, relative as relative2 } from "node:path";
 
 // src/lib/editor-shell.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "node:fs";
 import { platform as platform2 } from "node:os";
 import { delimiter, join as join9 } from "node:path";
 var DEFAULT_FALLBACKS = ["vi"];
@@ -10228,7 +10774,7 @@ async function runEditor(args) {
       message: `${command} exited with code ${exitCode}. The file may be unsaved; re-run after fixing.`
     };
   }
-  const contents = readFileSync12(args.filePath, "utf-8");
+  const contents = readFileSync14(args.filePath, "utf-8");
   return { ok: true, contents, command };
 }
 
@@ -10368,32 +10914,271 @@ function normalizeTool(raw) {
   };
 }
 async function fetchEnrichedToolDetail(args) {
-  const data = await api.get("/api/v1/project/tools", {
-    organizationId: args.organizationId,
-    projectId: args.projectId
-  });
-  const match = data.tools.find((t) => t.id === args.toolId);
+  const tools = await fetchAllPages("/api/v1/project/tools", { organizationId: args.organizationId, projectId: args.projectId }, "tools");
+  const match = tools.find((t) => t.id === args.toolId);
   return match ? normalizeTool(match) : null;
 }
 async function fetchEnrichedToolByName(args) {
-  const data = await api.get("/api/v1/project/tools", {
-    organizationId: args.organizationId,
-    projectId: args.projectId
-  });
-  const match = data.tools.find((t) => t.serverId === args.serverId && t.name === args.toolName);
+  const tools = await fetchAllPages("/api/v1/project/tools", { organizationId: args.organizationId, projectId: args.projectId }, "tools");
+  const match = tools.find((t) => t.serverId === args.serverId && t.name === args.toolName);
   return match ? normalizeTool(match) : null;
 }
 
+// src/commands/tools-enrich-batch.ts
+var POLL_INTERVAL_MS = 2000;
+var MS_PER_TOOL = 3 * 60 * 1000;
+var MIN_POLL_TIMEOUT_MS = 10 * 60 * 1000;
+var MAX_POLL_TIMEOUT_MS = 90 * 60 * 1000;
+function pollTimeoutMsForJob(total) {
+  const scaled = Math.max(0, total) * MS_PER_TOOL;
+  return Math.min(MAX_POLL_TIMEOUT_MS, Math.max(MIN_POLL_TIMEOUT_MS, scaled));
+}
+function sleep(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
+async function runToolsEnrichAll(args) {
+  const toolIds = await resolveOnlyToolIds(args);
+  let job;
+  try {
+    const started = await api.post("/api/v1/server/enrich", {
+      organizationId: args.ctx.organizationId,
+      projectId: args.ctx.projectId,
+      serverId: args.ctx.serverId,
+      apply: args.apply,
+      ...toolIds ? { toolIds } : {},
+      ...args.modelId ? { modelId: args.modelId } : {}
+    });
+    job = started.job;
+  } catch (err) {
+    if (err instanceof McpCloudApiError) {
+      printError(`Enrichment job failed to start (HTTP ${err.status}): ${err.error.message}`);
+    } else {
+      printError(`Enrichment job failed to start: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    throw new CliExitError(1);
+  }
+  if (!args.wait) {
+    if (isJsonMode()) {
+      printJson({ ok: true, job, waited: false });
+      return;
+    }
+    printSuccess(`Queued ${job.total} tool${job.total === 1 ? "" : "s"} ${c.dim(`(job ${job.id})`)}`);
+    printInfo(`  ${c.dim("Poll with:")} ${c.bold(`mcp tools enrich --all --job ${job.id}`)}`);
+    return;
+  }
+  if (!isJsonMode()) {
+    printStep(`Enriching ${job.total} tool${job.total === 1 ? "" : "s"}${args.modelId ? c.dim(` (model ${args.modelId})`) : ""}…`);
+  }
+  const finalJob = await pollUntilTerminal(args.ctx, job);
+  reportJob(finalJob, args.apply);
+}
+async function pollEnrichmentJob(ctx, jobId) {
+  const job = await fetchJob(ctx, jobId);
+  if (job.status === "queued" || job.status === "running") {
+    reportJob(await pollUntilTerminal(ctx, job), job.total > 0);
+    return;
+  }
+  reportJob(job, true);
+}
+async function fetchJob(ctx, jobId) {
+  try {
+    const data = await api.get("/api/v1/server/enrich", {
+      organizationId: ctx.organizationId,
+      jobId
+    });
+    return data.job;
+  } catch (err) {
+    if (err instanceof McpCloudApiError) {
+      printError(`Could not read job ${jobId} (HTTP ${err.status}): ${err.error.message}`);
+    } else {
+      printError(`Could not read job ${jobId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    throw new CliExitError(1);
+  }
+}
+async function pollUntilTerminal(ctx, initial) {
+  const timeoutMs = pollTimeoutMsForJob(initial.total);
+  const deadline = Date.now() + timeoutMs;
+  let job = initial;
+  let lastCompleted = -1;
+  while (job.status === "queued" || job.status === "running") {
+    if (Date.now() > deadline) {
+      printWarn(`Still running after ${Math.round(timeoutMs / 60000)} minutes — the job continues server-side.`);
+      printInfo(`  ${c.dim("Poll with:")} ${c.bold(`mcp tools enrich --all --job ${job.id}`)}`);
+      throw new CliExitError(0);
+    }
+    await sleep(POLL_INTERVAL_MS);
+    job = await fetchJob(ctx, job.id);
+    if (!isJsonMode() && job.completed !== lastCompleted) {
+      lastCompleted = job.completed;
+      printInfo(c.dim(`  ${job.completed}/${job.total} done · ${job.failed} failed`));
+    }
+  }
+  return job;
+}
+function reportJob(job, applied) {
+  const results = job.results ?? [];
+  if (isJsonMode()) {
+    printJson({ ok: job.failed === 0 && job.status === "completed", job });
+    if (job.failed > 0 || job.status === "failed")
+      throw new CliExitError(1);
+    return;
+  }
+  if (job.status === "failed") {
+    printError(`Enrichment job failed: ${job.error ?? "unknown error"}`);
+    printInfo(c.dim(`  ${job.succeeded} of ${job.total} tools completed before it stopped.`));
+    throw new CliExitError(1);
+  }
+  const cachedCount = results.filter((entry) => entry.cached).length;
+  if (job.failed === 0) {
+    printSuccess(`Enriched ${job.succeeded} tool${job.succeeded === 1 ? "" : "s"} ${c.dim(`(${cachedCount} cached · ${applied ? "applied" : "proposed only"})`)}`);
+  } else {
+    printWarn(`Enriched ${job.succeeded} of ${job.total}; ${job.failed} failed ${c.dim(`(${cachedCount} cached)`)}`);
+    for (const entry of results.filter((r) => r.status === "failed")) {
+      printInfo(`  ${c.dim("✗")} ${entry.toolName}: ${entry.error ?? "unknown error"}`);
+    }
+  }
+  const writeFailures = results.filter((r) => r.status === "succeeded" && r.error);
+  if (writeFailures.length > 0) {
+    printWarn(`${writeFailures.length} enrichment${writeFailures.length === 1 ? "" : "s"} ran but could not be applied:`);
+    for (const entry of writeFailures) {
+      printInfo(`  ${c.dim("!")} ${entry.toolName}: ${entry.error}`);
+    }
+  }
+  if (job.failed > 0)
+    throw new CliExitError(1);
+}
+async function resolveOnlyToolIds(args) {
+  if (args.only.length === 0)
+    return null;
+  const list = await fetchToolsForServer(args.ctx);
+  const byName = new Map(list.map((tool) => [tool.name, tool.id]));
+  const ids = [];
+  const missing = [];
+  for (const name of args.only) {
+    const id = byName.get(name);
+    if (id)
+      ids.push(id);
+    else
+      missing.push(name);
+  }
+  if (missing.length > 0) {
+    printError(`Not found on this server: ${missing.join(", ")}`);
+    if (list.length > 0) {
+      const sample = list.slice(0, 5).map((tool) => tool.name).join(", ");
+      printInfo(`  ${c.dim("Available:")} ${sample}${list.length > 5 ? c.dim(`, +${list.length - 5} more`) : ""}`);
+    }
+    throw new CliExitError(1);
+  }
+  return ids;
+}
+
+// src/commands/tools-enrich-apply.ts
+function printSuggestion(tool, suggestion) {
+  const sDesc = suggestion.enrichedDescription?.trim() || null;
+  const sTags = suggestion.suggestedTags ?? [];
+  const sRisk = suggestion.riskClassification?.riskClass ?? null;
+  const sIdem = suggestion.riskClassification?.idempotent ?? null;
+  printInfo(c.bold("Suggested vs applied:"));
+  printInfo(diffRow("description", tool.description, sDesc));
+  printInfo(diffRow("tags", tool.semanticTags.join(", ") || null, sTags.join(", ") || null));
+  printInfo(diffRow("riskClass", tool.riskClass, sRisk));
+  printInfo(diffRow("idempotent", tool.idempotent === null ? null : String(tool.idempotent), sIdem === null ? null : String(sIdem)));
+}
+function diffRow(label, applied, suggested) {
+  const left = c.dim(`  ${label.padEnd(14)}`);
+  if (applied === suggested) {
+    return `${left}${c.dim(applied ?? "(none)")} ${c.dim("(unchanged)")}`;
+  }
+  return `${left}${applied ?? c.dim("(none)")}  ${c.dim("→")}  ${c.bold(suggested ?? c.dim("(clear)"))}`;
+}
+async function applySuggestion(tool, ctx) {
+  if (!tool.enrichment) {
+    return { ok: false, message: "No suggestion to apply." };
+  }
+  const desc = tool.enrichment.enrichedDescription?.trim() ?? null;
+  const tags = tool.enrichment.suggestedTags;
+  const risk = tool.enrichment.riskClassification?.riskClass ?? null;
+  const idem = tool.enrichment.riskClassification?.idempotent ?? null;
+  try {
+    const result = await api.patch("/api/v1/server/tool", {
+      organizationId: ctx.organizationId,
+      projectId: ctx.projectId,
+      serverId: ctx.serverId,
+      toolId: tool.id,
+      expectedUpdatedAt: tool.updatedAt,
+      description: desc,
+      semanticTags: tags,
+      riskClass: risk,
+      idempotent: idem
+    });
+    return {
+      ok: true,
+      updatedAt: result.tool.updatedAt,
+      changedFields: result.patchedFields
+    };
+  } catch (err) {
+    if (err instanceof McpCloudApiError) {
+      if (err.error.code === "tool_metadata_conflict") {
+        return {
+          ok: false,
+          message: `Conflict — the tool was modified by someone else after enrichment. Run \`mcp tools pull ${tool.name}\` and rerun \`mcp tools enrich ${tool.name} --apply\`.`
+        };
+      }
+      return {
+        ok: false,
+        message: `Apply failed (HTTP ${err.status}): ${err.error.message}`
+      };
+    }
+    return {
+      ok: false,
+      message: `Apply failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
 // src/commands/tools-enrich.ts
 function registerToolsEnrichCommand(tools) {
-  tools.command("enrich <name>").description("Run AI enrichment for a tool. Prints the suggested vs applied diff; pass --apply to push the suggestion to the cloud.").option("--org <organizationId>", "Organization ID (defaults to .mcpcloud/state.json)").option("--server <server>", "Server (id, name, or slug; defaults to .mcpcloud/state.json)").option("--apply", "Apply the suggestion immediately (PATCH /api/v1/server/tool with the suggested values).").option("--model <id>", "Use a specific model ID for the rewrite (defaults to org / dashboard config)").addHelpText("after", [
+  tools.command("enrich [name]").description("Run AI enrichment for one tool (prints the suggested vs applied diff), or for the whole server with --all.").option("--org <organizationId>", "Organization ID (defaults to .mcpcloud/state.json)").option("--server <server>", "Server (id, name, or slug; defaults to .mcpcloud/state.json)").option("--all", "Enrich every tool on the server as one background job, applying each result. One request, not one per tool.").option("--only <names>", "With --all: comma-separated tool names to limit the job to.").option("--no-apply", "With --all: generate suggestions without writing them onto the tools.").option("--no-wait", "With --all: print the job id and exit instead of following it.").option("--job <jobId>", "Poll an enrichment job started earlier.").option("--apply", "Apply the suggestion immediately (PATCH /api/v1/server/tool with the suggested values).").option("--model <id>", "Use a specific model ID for the rewrite (defaults to org / dashboard config)").addHelpText("after", [
     "",
     "Examples:",
     "  $ mcp tools enrich get_user                 # generate + show suggestion",
     "  $ mcp tools enrich get_user --apply         # generate + push to cloud",
-    "  $ mcp tools enrich get_user --model abc123"
+    "  $ mcp tools enrich --all                    # whole server, one job",
+    "  $ mcp tools enrich --all --only a,b         # just these two",
+    "  $ mcp tools enrich --all --no-wait          # queue it and get the job id",
+    "  $ mcp tools enrich --job job_abc123         # follow a job started earlier"
   ].join(`
 `)).action(runAction(async (name, opts) => {
+    const batchMode = Boolean(opts.all) || Boolean(opts.job);
+    if (name && batchMode) {
+      printError("Pass a tool name or --all/--job, not both.");
+      throw new CliExitError(1);
+    }
+    if (!name && !batchMode) {
+      printError("Name a tool to enrich, or pass --all for every tool on the server.");
+      throw new CliExitError(1);
+    }
+    if (batchMode) {
+      const ctx = await resolveToolsContext({
+        orgOverride: opts.org,
+        serverOverride: opts.server
+      });
+      if (!ctx)
+        return;
+      if (opts.job) {
+        await pollEnrichmentJob(ctx, opts.job);
+        return;
+      }
+      await runToolsEnrichAll({
+        ctx,
+        only: (opts.only ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0),
+        apply: opts.apply !== false,
+        modelId: opts.model,
+        wait: opts.wait !== false
+      });
+      return;
+    }
     await runToolsEnrich({
       toolName: name,
       orgOverride: opts.org,
@@ -10430,6 +11215,7 @@ async function runToolsEnrich(args) {
       projectId: ctx.projectId,
       serverId: ctx.serverId,
       toolId: target.id,
+      apply: false,
       ...args.modelId ? { modelId: args.modelId } : {}
     });
   } catch (err) {
@@ -10496,68 +11282,6 @@ async function runToolsEnrich(args) {
   printSuccess(`Applied ${c.bold(args.toolName)} ${c.dim(`(${applyResult.changedFields.length} field${applyResult.changedFields.length === 1 ? "" : "s"} patched)`)}`);
   printInfo(`  ${c.dim("Run")} ${c.bold(`mcp tools pull ${args.toolName}`)} ${c.dim("to refresh your local copy.")}`);
 }
-function printSuggestion(tool, suggestion) {
-  const sDesc = suggestion.enrichedDescription?.trim() || null;
-  const sTags = suggestion.suggestedTags ?? [];
-  const sRisk = suggestion.riskClassification?.riskClass ?? null;
-  const sIdem = suggestion.riskClassification?.idempotent ?? null;
-  printInfo(c.bold("Suggested vs applied:"));
-  printInfo(diffRow("description", tool.description, sDesc));
-  printInfo(diffRow("tags", tool.semanticTags.join(", ") || null, sTags.join(", ") || null));
-  printInfo(diffRow("riskClass", tool.riskClass, sRisk));
-  printInfo(diffRow("idempotent", tool.idempotent === null ? null : String(tool.idempotent), sIdem === null ? null : String(sIdem)));
-}
-function diffRow(label, applied, suggested) {
-  const left = c.dim(`  ${label.padEnd(14)}`);
-  if (applied === suggested) {
-    return `${left}${c.dim(applied ?? "(none)")} ${c.dim("(unchanged)")}`;
-  }
-  return `${left}${applied ?? c.dim("(none)")}  ${c.dim("→")}  ${c.bold(suggested ?? c.dim("(clear)"))}`;
-}
-async function applySuggestion(tool, ctx) {
-  if (!tool.enrichment) {
-    return { ok: false, message: "No suggestion to apply." };
-  }
-  const desc = tool.enrichment.enrichedDescription?.trim() ?? null;
-  const tags = tool.enrichment.suggestedTags;
-  const risk = tool.enrichment.riskClassification?.riskClass ?? null;
-  const idem = tool.enrichment.riskClassification?.idempotent ?? null;
-  try {
-    const result = await api.patch("/api/v1/server/tool", {
-      organizationId: ctx.organizationId,
-      projectId: ctx.projectId,
-      serverId: ctx.serverId,
-      toolId: tool.id,
-      expectedUpdatedAt: tool.updatedAt,
-      description: desc,
-      semanticTags: tags,
-      riskClass: risk,
-      idempotent: idem
-    });
-    return {
-      ok: true,
-      updatedAt: result.tool.updatedAt,
-      changedFields: result.patchedFields
-    };
-  } catch (err) {
-    if (err instanceof McpCloudApiError) {
-      if (err.error.code === "tool_metadata_conflict") {
-        return {
-          ok: false,
-          message: `Conflict — the tool was modified by someone else after enrichment. Run \`mcp tools pull ${tool.name}\` and rerun \`mcp tools enrich ${tool.name} --apply\`.`
-        };
-      }
-      return {
-        ok: false,
-        message: `Apply failed (HTTP ${err.status}): ${err.error.message}`
-      };
-    }
-    return {
-      ok: false,
-      message: `Apply failed: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
 
 // src/commands/tools-handlers.ts
 var STATUS_LABEL = {
@@ -11077,7 +11801,6 @@ function diffLine2(label, applied, suggested) {
 }
 
 // src/commands/tools.ts
-var PROJECT_TOOLS_PAGE_LIMIT = 100;
 function registerToolCommands(program2) {
   const tools = program2.command("tools").description("Inspect and edit tools on a project or server");
   tools.command("list").description("List tools for a project, or scope to a single server with --server").option("--org <organizationId>", "Organization ID").option("--project <project>", "List every tool in this project (id or name)").option("--server <server>", "List only the tools that belong to this server — id, name, or slug (the CLI resolves its project, fetches the project tools, then filters to this server)").action(runAction(async (opts) => {
@@ -11097,13 +11820,8 @@ function registerToolCommands(program2) {
       });
       projectId = serverData.server.projectId;
     }
-    const data = await api.get("/api/v1/project/tools", {
-      limit: String(PROJECT_TOOLS_PAGE_LIMIT),
-      organizationId: orgId,
-      projectId
-    });
-    const truncated = data.tools.length >= PROJECT_TOOLS_PAGE_LIMIT;
-    const rows = resolvedServerId ? data.tools.filter((t) => t.serverId === resolvedServerId) : data.tools;
+    const { rows: allTools, payload } = await fetchAllPagesWithEnvelope("/api/v1/project/tools", { organizationId: orgId, projectId }, "tools");
+    const rows = resolvedServerId ? allTools.filter((t) => t.serverId === resolvedServerId) : allTools;
     printList(rows.map((t) => ({
       name: t.name,
       method: t.endpoint?.method ?? t.method ?? "—",
@@ -11116,10 +11834,7 @@ function registerToolCommands(program2) {
       { key: "path", label: "Path", width: 32 },
       { key: "enrichment", label: "Enrichment", width: 12 },
       { key: "description", label: "Description", width: 60 }
-    ], resolvedServerId ? { ...data, tools: rows, truncated } : { ...data, truncated });
-    if (truncated) {
-      printWarn(`Showing the first ${PROJECT_TOOLS_PAGE_LIMIT} tools — this project has more. ` + "Filter with --server, or read them from the deployed endpoint with `mcp invoke <server> --list`.");
-    }
+    ], resolvedServerId ? { ...payload, tools: rows } : payload);
   }));
   registerToolsShowCommand(tools);
   registerToolsDiffCommand(tools);
@@ -11281,13 +11996,13 @@ function isAgentKey(value) {
 }
 
 // src/commands/skills-lifecycle.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 function readValueOption2(raw) {
   if (raw === "@-") {
-    return readFileSync13(0, "utf8");
+    return readFileSync15(0, "utf8");
   }
   if (raw.startsWith("@")) {
-    return readFileSync13(raw.slice(1), "utf8");
+    return readFileSync15(raw.slice(1), "utf8");
   }
   return raw;
 }
@@ -11667,7 +12382,7 @@ function registerSkillMutationCommands(skills) {
 }
 
 // src/commands/skills-test-authoring.ts
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 var FIXTURE_MODES = [
   "baseline",
   "validationFailure",
@@ -11676,9 +12391,9 @@ var FIXTURE_MODES = [
 ];
 function readValueOption3(raw) {
   if (raw === "@-")
-    return readFileSync14(0, "utf8");
+    return readFileSync16(0, "utf8");
   if (raw.startsWith("@"))
-    return readFileSync14(raw.slice(1), "utf8");
+    return readFileSync16(raw.slice(1), "utf8");
   return raw;
 }
 function parseAssertionsOption(raw) {
@@ -12247,14 +12962,11 @@ function registerSkillCommands(program2) {
 `)).action(runAction(async (opts) => {
     const orgId = await resolveOrgId(opts.org);
     const projectId = await resolveOptionalProjectId(opts.project, orgId);
-    const params = {
-      organizationId: orgId,
-      limit: opts.limit
-    };
+    const params = { organizationId: orgId };
     if (projectId)
       params["projectId"] = projectId;
-    const data = await api.get("/api/v1/skills", params);
-    printList(data.skills.map((s) => ({
+    const { rows: skillRows, payload } = await fetchAllPagesWithEnvelope("/api/v1/skills", params, "skills", { max: parseRowCap(opts.limit) });
+    printList(skillRows.map((s) => ({
       id: s.id,
       name: s.name,
       project: s.projectName,
@@ -12268,7 +12980,7 @@ function registerSkillCommands(program2) {
       { key: "status", label: "Status", width: 10 },
       { key: "version", label: "Version", width: 8 },
       { key: "updated", label: "Updated", width: 22 }
-    ], data);
+    ], payload);
   }));
   skills.command("get <skill>").description("Get details for a single skill (accepts id or name)").option("--org <organizationId>", "Organization ID").action(runAction(async (skillRef, opts) => {
     const orgId = await resolveOrgId(opts.org);
@@ -12526,7 +13238,7 @@ import { join as join18, relative as relative6 } from "node:path";
 import {
   existsSync as existsSync14,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync17,
   rmSync as rmSync2,
   writeFileSync as writeFileSync8
 } from "node:fs";
@@ -12663,7 +13375,7 @@ import { spawnSync } from "node:child_process";
 import {
   existsSync as existsSync15,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync18,
   writeFileSync as writeFileSync9
 } from "node:fs";
 import { dirname as dirname8, join as join13 } from "node:path";
@@ -12740,7 +13452,7 @@ function isGitAvailable() {
 }
 function applyLocalExcludes(repoDir) {
   const excludePath = join13(repoDir, ".git", "info", "exclude");
-  const existing = existsSync15(excludePath) ? readFileSync16(excludePath, "utf-8") : "";
+  const existing = existsSync15(excludePath) ? readFileSync18(excludePath, "utf-8") : "";
   const next = mergeLocalExcludes(existing);
   if (next === null)
     return;
@@ -28038,6 +28750,12 @@ function buildHostScript(options) {
     ``,
     `async function main() {`,
     `  const env = loadEnv()`,
+    `  try {`,
+    `    const rt = await import('@mcpcloud/runtime/node')`,
+    `    if (typeof rt.registerNodeCodeModeEngine === 'function') rt.registerNodeCodeModeEngine()`,
+    `  } catch (err) {`,
+    `    console.error('[mcp dev] code mode unavailable locally:', err?.message ?? err)`,
+    `  }`,
     `  const mod = await import(pathToFileURL(new URL(ENTRY, import.meta.url).pathname).href)`,
     `  const handler = mod.default`,
     `  if (!handler || typeof handler.fetch !== 'function') {`,
@@ -28108,7 +28826,7 @@ import {
   appendFileSync as appendFileSync2,
   existsSync as existsSync18,
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync19,
   readdirSync as readdirSync2,
   renameSync,
   statSync as statSync2
@@ -28160,7 +28878,7 @@ function readAll(dir) {
   for (const path of [...listRotatedFiles(dir), activeFilePath(dir)]) {
     if (!existsSync18(path))
       continue;
-    out.push(...parseLines(readFileSync17(path, "utf-8")));
+    out.push(...parseLines(readFileSync19(path, "utf-8")));
   }
   return out;
 }
@@ -28427,8 +29145,9 @@ async function prepareDev(opts) {
 
 // src/lib/dev/tree-sync.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync21, mkdirSync as mkdirSync14, readdirSync as readdirSync3, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync14, readdirSync as readdirSync3, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join19 } from "node:path";
+var AUTHORING_GUIDE_FILE = "AGENTS.md";
 var STRUCTURAL_FRONTMATTER_KEYS = [
   "inputSchema",
   "outputSchema",
@@ -28444,11 +29163,11 @@ function listToolFiles(devRootDir, serverId) {
   const dir = serverToolsDir(devRootDir, serverId);
   if (!existsSync21(dir))
     return [];
-  return readdirSync3(dir).filter((entry) => entry.endsWith(".md")).map((entry) => entry.slice(0, -3)).sort();
+  return readdirSync3(dir).filter((entry) => entry.endsWith(".md")).filter((entry) => entry !== AUTHORING_GUIDE_FILE).map((entry) => entry.slice(0, -3)).sort();
 }
 function readToolFile(devRootDir, serverId, toolName) {
   const file = join19(serverToolsDir(devRootDir, serverId), `${toolName}.md`);
-  const raw = readFileSync18(file, "utf-8");
+  const raw = readFileSync20(file, "utf-8");
   try {
     return { raw, view: parseToolMarkdown(raw) };
   } catch (err) {
@@ -28466,6 +29185,21 @@ function findStructuralEdit(raw) {
   }
   return null;
 }
+async function writeAuthoringGuide(args) {
+  try {
+    const response = await api.get("/api/v1/tool-authoring-guide");
+    const markdown = response?.guide?.markdown;
+    if (typeof markdown !== "string" || !markdown.trim())
+      return null;
+    const dir = serverToolsDir(args.devRootDir, args.serverId);
+    mkdirSync14(dir, { recursive: true });
+    const guidePath = join19(dir, AUTHORING_GUIDE_FILE);
+    writeFileSync13(guidePath, markdown, "utf8");
+    return guidePath;
+  } catch {
+    return null;
+  }
+}
 async function pullToolTree(args) {
   const tools = await fetchToolsForServer({
     organizationId: args.organizationId,
@@ -28477,7 +29211,11 @@ async function pullToolTree(args) {
     serverId: args.serverId,
     tools
   });
-  return { ...result, tools };
+  const guidePath = await writeAuthoringGuide({
+    devRootDir: args.devRootDir,
+    serverId: args.serverId
+  });
+  return { ...result, guidePath, tools };
 }
 function planPush(args) {
   const changes = [];
@@ -28549,7 +29287,7 @@ function listHandlerFiles(devRootDir) {
     return [];
   return readdirSync3(dir).filter((entry) => entry.endsWith(".ts") && !entry.endsWith(".definition.ts")).sort().map((entry) => ({
     slug: entry.slice(0, -3),
-    source: readFileSync18(join19(dir, entry), "utf-8")
+    source: readFileSync20(join19(dir, entry), "utf-8")
   }));
 }
 function writeHandlerManifest(args) {
@@ -28577,7 +29315,7 @@ function recordHandlerPushed(args) {
     serverId: args.serverId,
     version: 1
   };
-  manifest.handlers[args.slug] = hashSource2(readFileSync18(file, "utf-8"));
+  manifest.handlers[args.slug] = hashSource2(readFileSync20(file, "utf-8"));
   writeFileSync13(handlerManifestPath(args.devRootDir, args.serverId), JSON.stringify(manifest, null, 2), "utf-8");
 }
 function readHandlerManifest(devRootDir, serverId) {
@@ -28585,7 +29323,7 @@ function readHandlerManifest(devRootDir, serverId) {
   if (!existsSync21(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync18(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync20(file, "utf-8"));
     return parsed.version === 1 && parsed.handlers ? parsed : null;
   } catch {
     return null;
@@ -28649,6 +29387,7 @@ function describeToolPush(toolName, result) {
       return {
         detail: `updated ${result.changedFields.join(", ") || "metadata"}`,
         ok: true,
+        ...result.notices.length > 0 ? { notices: result.notices.map((notice) => notice.message) } : {},
         target: toolName
       };
     case "noop":
@@ -28797,6 +29536,7 @@ function registerTreeCommands(program2) {
           name: target.serverName,
           projectId: target.projectId
         },
+        authoringGuide: tools.guidePath,
         toolFilesRemoved: tools.filesRemoved,
         toolFilesWritten: tools.filesWritten,
         treeDir: prepared.destDir
@@ -28809,6 +29549,9 @@ function registerTreeCommands(program2) {
       handlers: handlerCount,
       tree: prepared.destDir
     });
+    if (tools.guidePath) {
+      printInfo(`Editing rules for agents: ${tools.guidePath}`);
+    }
     printInfo("Edit, then run `mcp push --dry-run`.");
   }));
   program2.command("push").description("Push local tool metadata and handler edits back to the cloud (diffed against your last pull)").option("--server <server>", "Server to push to (id or name)").option("--org <organizationId>", "Organization ID").option("--dry-run", "Print the change set and exit without writing").addHelpText("after", [
@@ -28881,6 +29624,9 @@ function registerTreeCommands(program2) {
     }
     for (const outcome of applied) {
       printSuccess(`${outcome.target}: ${outcome.detail}`);
+      for (const notice of outcome.notices ?? []) {
+        printWarn(`${outcome.target}: ${notice}`);
+      }
     }
     for (const outcome of refused) {
       printError(`${outcome.target}: ${outcome.detail}`);
@@ -29553,7 +30299,7 @@ import { isAbsolute as isAbsolute4, relative as relative7, resolve as resolve9 }
 import {
   existsSync as existsSync22,
   mkdirSync as mkdirSync15,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync21,
   readdirSync as readdirSync4,
   unlinkSync,
   writeFileSync as writeFileSync14
@@ -29597,7 +30343,7 @@ function listSessions() {
       continue;
     const path = join21(dir, entry);
     try {
-      const parsed = JSON.parse(readFileSync19(path, "utf-8"));
+      const parsed = JSON.parse(readFileSync21(path, "utf-8"));
       if (typeof parsed.pid !== "number") {
         unlinkSync(path);
         continue;
@@ -29995,7 +30741,7 @@ async function runDevTail(opts) {
         emitLines(complete, opts.filter);
       }
     }
-    await sleep(intervalMs);
+    await sleep2(intervalMs);
   }
 }
 function parseInterval(raw) {
@@ -30056,7 +30802,7 @@ function emitLines(text, filter) {
 `);
   }
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 
@@ -30956,19 +31702,19 @@ import { homedir as homedir4 } from "node:os";
 import { join as join26 } from "node:path";
 
 // src/lib/dev/agent-connectors/json-config-utils.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname10, join as join25, basename } from "node:path";
 function readJsonFile(path) {
   if (!existsSync28(path))
     return { ok: true, value: {} };
   try {
-    const raw = readFileSync20(path, "utf-8");
+    const raw = readFileSync22(path, "utf-8");
     if (!raw.trim())
       return { ok: true, value: {} };
     return { ok: true, value: JSON.parse(raw) };
   } catch {
     try {
-      return { ok: false, raw: readFileSync20(path, "utf-8") };
+      return { ok: false, raw: readFileSync22(path, "utf-8") };
     } catch {
       return { ok: false };
     }
@@ -30990,7 +31736,7 @@ function backupConfig(args) {
   const filename = `${args.agentId}__${basename(args.configPath)}.bak`;
   const backupPath = join25(args.backupsDir, filename);
   if (!existsSync28(backupPath)) {
-    const raw = readFileSync20(args.configPath, "utf-8");
+    const raw = readFileSync22(args.configPath, "utf-8");
     writeFileSync15(backupPath, raw, "utf-8");
   }
   return { backupPath, existed: true };
@@ -31001,7 +31747,7 @@ function restoreFromBackup(args) {
   if (!existsSync28(backupPath)) {
     return { restored: false };
   }
-  const raw = readFileSync20(backupPath, "utf-8");
+  const raw = readFileSync22(backupPath, "utf-8");
   mkdirSync16(dirname10(args.configPath), { recursive: true });
   writeFileSync15(args.configPath, raw, "utf-8");
   return { restored: true };
@@ -31090,7 +31836,7 @@ var claudeCodeConnector = {
 import {
   existsSync as existsSync30,
   mkdirSync as mkdirSync17,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync23,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync17
 } from "node:fs";
@@ -31149,7 +31895,7 @@ var codexConnector = {
     });
     let existing = "";
     if (existsSync30(path)) {
-      existing = readFileSync21(path, "utf-8");
+      existing = readFileSync23(path, "utf-8");
     }
     const conflict = findSectionRange(existing, args.name) !== null;
     let next = existing;
@@ -31171,7 +31917,7 @@ var codexConnector = {
   async remove(args) {
     const path = configPath2();
     if (existsSync30(path)) {
-      const existing = readFileSync21(path, "utf-8");
+      const existing = readFileSync23(path, "utf-8");
       const range = findSectionRange(existing, args.name);
       if (range) {
         const next = existing.slice(0, range.start) + existing.slice(range.end);
@@ -31184,7 +31930,7 @@ var codexConnector = {
       agentId: this.id
     });
     if (!restored.restored && existsSync30(path)) {
-      const after = readFileSync21(path, "utf-8");
+      const after = readFileSync23(path, "utf-8");
       if (!after.trim()) {
         try {
           unlinkSync3(path);
@@ -32437,12 +33183,8 @@ function registerDeploymentCommands(program2) {
   deployments.command("list").description("List deployments in an organization").option("--org <organizationId>", "Organization ID").option("--status <status>", `Filter: ${DEPLOYMENT_STATUSES.join(" | ")}`, "active").option("--limit <n>", "Maximum results (default 25)", parsePositiveIntOption("limit"), "25").action(runAction(async (opts) => {
     const orgId = await resolveOrgId(opts.org);
     const status = validateChoice("status", opts.status, DEPLOYMENT_STATUSES);
-    const data = await api.get("/api/v1/deployments", {
-      organizationId: orgId,
-      status,
-      limit: opts.limit
-    });
-    printList(data.deployments.map((d) => ({
+    const { rows: deploymentRows, payload } = await fetchAllPagesWithEnvelope("/api/v1/deployments", { organizationId: orgId, status }, "deployments", { max: parseRowCap(opts.limit) });
+    printList(deploymentRows.map((d) => ({
       id: d.id,
       server: d.serverName,
       project: d.projectName,
@@ -32460,7 +33202,7 @@ function registerDeploymentCommands(program2) {
       { key: "status", label: "Status", width: 10 },
       { key: "version", label: "Version", width: 10 },
       { key: "deployed", label: "Deployed", width: 22 }
-    ], data);
+    ], payload);
   }));
   deployments.command("get <deployment>").description("Show one deployment by id or selector (latest | active | previous, with --server)").option("--org <organizationId>", "Organization ID").option("--server <server>", SELECTOR_SERVER_HELP).addHelpText("after", SELECTOR_HELP).action(runAction(async (deploymentRef, opts) => {
     const orgId = await resolveOrgId(opts.org);
@@ -32666,12 +33408,12 @@ async function confirmRollback(deploymentId) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync36, statSync as statSync6, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync36, statSync as statSync6, readFileSync as readFileSync25 } from "node:fs";
 import { homedir as homedir9, platform as platform6 } from "node:os";
 import { join as join32, delimiter as delimiter3 } from "node:path";
 
 // src/lib/version-check.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync21 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync18, readFileSync as readFileSync24, writeFileSync as writeFileSync21 } from "node:fs";
 import { join as join31 } from "node:path";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS2 = 2000;
@@ -32686,7 +33428,7 @@ function readCache() {
   if (!existsSync35(cacheFile()))
     return null;
   try {
-    const raw = JSON.parse(readFileSync22(cacheFile(), "utf-8"));
+    const raw = JSON.parse(readFileSync24(cacheFile(), "utf-8"));
     if (typeof raw.latest !== "string" || typeof raw.fetchedAt !== "number")
       return null;
     return { latest: raw.latest, fetchedAt: raw.fetchedAt };
@@ -32832,7 +33574,7 @@ function checkConfigFile() {
     } catch {}
   }
   try {
-    JSON.parse(readFileSync23(path, "utf-8"));
+    JSON.parse(readFileSync25(path, "utf-8"));
   } catch (err) {
     return {
       name: "Config file",
@@ -33678,7 +34420,7 @@ function registerInstallationCommands(program2) {
 }
 
 // src/commands/invoke.ts
-import { existsSync as existsSync37, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync26 } from "node:fs";
 import { join as join33 } from "node:path";
 
 // src/lib/dev/local-invoke.ts
@@ -33771,9 +34513,9 @@ function selectCodeModeInvocation(args) {
 }
 function readCodeOption(raw) {
   if (raw === "@-")
-    return readFileSync24(0, "utf-8");
+    return readFileSync26(0, "utf-8");
   if (raw.startsWith("@"))
-    return readFileSync24(raw.slice(1), "utf-8");
+    return readFileSync26(raw.slice(1), "utf-8");
   return raw;
 }
 function parseTimeoutMs4(value, fallbackMs) {
@@ -34055,7 +34797,7 @@ async function runLocalInvoke(args) {
     throw new CliExitError(1);
   }
   const env = {
-    ...args.envFile ? parseEnvFile(readFileSync24(args.envFile, "utf-8")) : {},
+    ...args.envFile ? parseEnvFile(readFileSync26(args.envFile, "utf-8")) : {},
     ...parseEnvPairs(args.envPairs)
   };
   const port = await findAvailablePort({ range: 40, start: 43117 });
@@ -34653,7 +35395,7 @@ function registerUsageCommands(program2) {
 }
 
 // src/commands/metrics.ts
-function formatPercent(rate) {
+function formatPercent2(rate) {
   if (rate == null)
     return "—";
   return `${(rate * 100).toFixed(2)}%`;
@@ -34715,7 +35457,7 @@ function registerMetricsCommands(program2) {
       "rate-limited": m2.totals.rateLimitedCount,
       unauthorized: m2.totals.unauthorizedCount,
       failed: m2.totals.failedCount,
-      "error rate": formatPercent(errorRate),
+      "error rate": formatPercent2(errorRate),
       "avg duration": formatMs(m2.averageDurationMs),
       "avg cpu": formatMs(m2.averageCpuTimeMs),
       "last event": m2.lastEventAt ? formatDate(m2.lastEventAt) : "—"
@@ -35047,7 +35789,7 @@ import {
   existsSync as existsSync38,
   mkdirSync as mkdirSync19,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync27,
   rmSync as rmSync3,
   statSync as statSync7
 } from "node:fs";
@@ -35067,7 +35809,7 @@ function readManifestFromPackageDir(packageDir) {
     return null;
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync25(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
   } catch {
     return null;
   }
@@ -35819,8 +36561,9 @@ var CLI_EXAMPLES = {
   "tools handlers list": ["mcp tools handlers list srv_abc"],
   "tools diff": ["mcp tools diff srv_abc query_users"],
   "tools enrich": [
-    "mcp tools enrich srv_abc",
-    "mcp tools enrich srv_abc --only query_users"
+    "mcp tools enrich query_users",
+    "mcp tools enrich --all --server srv_abc",
+    "mcp tools enrich --all --only query_users,create_user"
   ],
   "tools pull": ["mcp tools pull srv_abc"],
   "tools pull-handler": ["mcp tools pull-handler srv_abc query_users"],
@@ -35861,7 +36604,7 @@ var PLAYBOOKS = [
       {
         description: "Re-write every tool description for agent comprehension.",
         verb: "tools enrich",
-        command: "mcp tools enrich srv_abc"
+        command: "mcp tools enrich --all --server srv_abc"
       },
       {
         description: "Deploy to the proxy.",
@@ -36800,7 +37543,7 @@ function displayValueFor(field, value) {
 import {
   existsSync as existsSync39,
   mkdirSync as mkdirSync20,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync28,
   writeFileSync as writeFileSync22
 } from "node:fs";
 import { join as join35 } from "node:path";
@@ -36882,7 +37625,7 @@ function readTuiState() {
     return {};
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync26(path, "utf-8"));
+    parsed = JSON.parse(readFileSync28(path, "utf-8"));
   } catch {
     return {};
   }