pipebrain-mcp 0.53.1 → 0.54.0

package/dist/main.js

@@ -367,7 +367,7 @@ var AGENT_CONFIG_ENTRIES = [
   { target: "agents/blind-spot-pass.md", sha256: "564751a751f7896e89c67e0d20788aff873e599766a3c30360073ba74e4c6099" },
   { target: "agents/code-verifier.md", sha256: "c3f0a3b7397f0c903056971e71f2640a979a52e6efd18b624b3d29716d1e43e0" },
   { target: "agents/heavy-implementer.md", sha256: "7d3af78d4241aaa67c283db245dd4065af6e8f55efce54c2f8623c1f83879830" },
-  { target: "agents/issue-header-writer.md", sha256: "8809b2913c71d021e8fa6c72fe70e2d1db8019b90ed93d85786f5236552c7da6" },
+  { target: "agents/issue-header-writer.md", sha256: "185d8c656216bfd755f23391761f172d80e23b0d8a10d58acea0110df91d5c84" },
   { target: "agents/spec-reviewer.md", sha256: "a46dc637006d1f810081046c57edcd731406727810ccc5e0b1c7d7b9b98be5ef" },
   { target: "agents/surgical-editor.md", sha256: "c8b7fe2ec8d76c396c0c698f36b0523be430b31e4b73b902409479a52d42ea5c" },
   { target: "pipebrain/hooks/block-bash4-features.js", sha256: "383b38169a1795d9da34aa1c939349b6a1f76bba1359d0af7fd14c11ea5da25f" },
@@ -376,17 +376,17 @@ var AGENT_CONFIG_ENTRIES = [
   { target: "pipebrain/hooks/pre-commit-publication-fitness.js", sha256: "68a4f5f15dea22057b7217ad54d5cf8c34a8c4aaa5ce139ace79911acece8504" },
   { target: "pipebrain/hooks/pre-commit-secret-scan.js", sha256: "1bc634774184e66748b3152016e806ef974449e976920fd710732170fdb4ad6b" },
   { target: "pipebrain/hooks/stop-orphaned-servers.js", sha256: "16ec7e690b3bd5eb7aceacefd462fc3ac4ae31ae0b5ee5280472fb9c34ffc09b" },
-  { target: "pipebrain/team.md", sha256: "6692dd20f27820cbd22f7272035e1b1e09ef8e1f83ef403874ae6c67d49085c0" },
+  { target: "pipebrain/team.md", sha256: "073a1f59681f09153e323b7cf0476c6860aa9a4584cdebf5ba754ad5251da13f" },
   { target: "rules/react-tailwind.md", sha256: "80bb51b2d8fd5782b7c742526544e7841ee38aa575faf7a8c7b4217ba5731989" },
   { target: "rules/shell.md", sha256: "499aac60b6419acb0bb362c0267b9399139dcceafb0eaf67702e40f3118b5c04" },
   { target: "rules/typescript.md", sha256: "c55eab0c243e38cdf903ab50b1e9d6d621516b893e602e1abff9a999a14e72d4" },
-  { target: "skills/capture-correction/SKILL.md", sha256: "907ee8fc8e7ea15c8296acd23a816e1f9c6454edcf37a93f18af79b1c542fb75" },
-  { target: "skills/pipebrain-header-pass/SKILL.md", sha256: "10545e3c1c5215b031e1c76281e65cd2ecf7420b3f07a4221824591a8263c5fc" },
-  { target: "skills/pipebrain-secrets/SKILL.md", sha256: "52c2136a3cca5612981d50b926195eae3e804911e1e9723dd5eba76e66b52d6f" },
-  { target: "skills/pipebrain-work-session/SKILL.md", sha256: "d65dd271e1fef00bc583eac1cab5007d7c156a43b40ee1698aef1d88e9ae78f9" },
-  { target: "skills/pipebrain-writing/SKILL.md", sha256: "8e5ed4636afcca0cacc220d8fa5310364d2d6854a9fc68ffa03e4c428989f8b8" },
-  { target: "skills/pipebrain/SKILL.md", sha256: "9fdad1b78bb506e9cd91ba55f4baee0adc5f4d2c5d9d418d0e8c922554e8df74" },
-  { target: "skills/requirements-altitude/SKILL.md", sha256: "60d1916da22a52138c046fcf4e5cd4cc420b7a5679a6652eb76573b7a69a1cf4" }
+  { target: "skills/capture-correction/SKILL.md", sha256: "43155819d172d2cd32474312df6244cc710f23cc76eeb8c0aa77664bd81dd9ca" },
+  { target: "skills/pipebrain-header-pass/SKILL.md", sha256: "ef163f0530def7ba90b1014a47efb98f86e4ba222c6ab4d4c6bfb549dfed10f1" },
+  { target: "skills/pipebrain-secrets/SKILL.md", sha256: "f74d3a97a94a026c612698fb3ba17da06891a217c7d44573075dd423189ae084" },
+  { target: "skills/pipebrain-work-session/SKILL.md", sha256: "d6803c66123e3c2715376d41f63cedefc08b5ceb12fa0bae1d9ad8c8cd5d200d" },
+  { target: "skills/pipebrain-writing/SKILL.md", sha256: "1496937104f6d7469fb8b1eb00b553502e8de0422366b2130a178f68bbcdbe44" },
+  { target: "skills/pipebrain/SKILL.md", sha256: "71c287f905af2ed9207d4d2829bbb5b2aa51f5abb486210c78a6a65d4da8f5e2" },
+  { target: "skills/requirements-altitude/SKILL.md", sha256: "ffe20eb73fbc73e1fd9bfaec5f9759736a4375dce5fedb015754b135fc12f225" }
 ];
 
 // ../../libs/agent-shared/dist/agent-config.js
@@ -15444,6 +15444,21 @@ var projectSchema = external_exports.object({
   environments: external_exports.array(projectEnvironmentSchema),
   milestones: external_exports.array(projectMilestoneSchema),
   deliverableTargets: external_exports.array(projectDeliverableTargetSchema),
+  /**
+   * The project's current release (PIPE-484), or `null` when none is active.
+   *
+   * DERIVED from the `milestones` array beside it — the row carrying `active: true` —
+   * rather than queried again, so the two spellings of one answer cannot disagree. It
+   * is carried at all because the summary read (see {@link projectSummarySchema}) has
+   * no milestone array to look in, and "which release is current" is the one milestone
+   * question a chooser asks; deriving it in every caller instead would be the same
+   * `find` written in each of them.
+   *
+   * `.nullable()` and REQUIRED, like `defaultEnvironmentId`: the server derives it on
+   * every row, so an absent key would mean a response predating the field while `null`
+   * means this project has no active milestone.
+   */
+  activeMilestone: projectMilestoneSchema.nullable(),
   openIssueCount: external_exports.number().int().nonnegative(),
   /**
    * What an issue's placement falls back to when neither it nor any ancestor carries a
@@ -15467,6 +15482,16 @@ var projectSchema = external_exports.object({
    */
   defaultIntegrationMode: integrationModeSchema
 });
+var projectSummarySchema = external_exports.object({
+  key: projectKeySchema,
+  name: external_exports.string().min(1),
+  openIssueCount: external_exports.number().int().nonnegative(),
+  activeMilestone: projectMilestoneSchema.nullable(),
+  defaultBranch: external_exports.string().nullable(),
+  defaultWorktree: external_exports.string().nullable(),
+  defaultBase: external_exports.string().nullable(),
+  defaultIntegrationMode: integrationModeSchema
+});
 var environmentSchema = external_exports.object({
   id: uuidSchema,
   orgId: uuidSchema,
@@ -15992,13 +16017,13 @@ var criterionInputSchema = external_exports.strictObject({
 var refusedIssueHeaderFields = {
   summary: external_exports.never({
     error: "summary cannot be set here \u2014 create or update the issue first, then write its header with set_issue_header"
-  }).optional().describe("Not writable here. The header summary is written by `set_issue_header`."),
+  }).optional().describe("Not writable here; `set_issue_header` writes it."),
   why: external_exports.never({
     error: "why cannot be set here \u2014 create or update the issue first, then write its header with set_issue_header"
-  }).optional().describe("Not writable here. The header reason is written by `set_issue_header`."),
+  }).optional().describe("Not writable here; `set_issue_header` writes it."),
   affectedSurfaces: external_exports.never({
     error: "affected surfaces cannot be set here \u2014 create or update the issue first, then write its header with set_issue_header"
-  }).optional().describe("Not writable here. The affected surfaces are written by `set_issue_header`.")
+  }).optional().describe("Not writable here; `set_issue_header` writes it.")
 };
 var createIssueInputSchema = external_exports.strictObject({
   ...refusedIssueHeaderFields,
@@ -16075,9 +16100,9 @@ var updateIssueInputSchema = external_exports.strictObject({
    * asks and a schema that could not tell them apart would make an issue's own value
    * impossible to remove.
    */
-  branch: external_exports.string().min(1, { message: "branch must not be empty \u2014 pass null to clear it" }).nullable().optional().describe("The branch this issue\u2019s work happens on. Pass null to clear it, so the issue inherits from the nearest ancestor carrying one and then from the project default."),
-  worktree: external_exports.string().min(1, { message: "worktree must not be empty \u2014 pass null to clear it" }).nullable().optional().describe("A label for the working tree this issue\u2019s work happens in \u2014 never a path, which is true only on the machine that wrote it. Pass null to clear it."),
-  base: external_exports.string().min(1, { message: "base must not be empty \u2014 pass null to clear it" }).nullable().optional().describe("What this issue\u2019s work integrates into. Pass null to clear it, so the issue inherits from its chain and then from the project default.")
+  branch: external_exports.string().min(1, { message: "branch must not be empty \u2014 pass null to clear it" }).nullable().optional().describe("The branch this issue\u2019s work happens on. Null clears it, so the issue inherits from the nearest ancestor carrying one, then from the project default."),
+  worktree: external_exports.string().min(1, { message: "worktree must not be empty \u2014 pass null to clear it" }).nullable().optional().describe("A label for the working tree this issue\u2019s work happens in, never a path. Null clears it."),
+  base: external_exports.string().min(1, { message: "base must not be empty \u2014 pass null to clear it" }).nullable().optional().describe("What this issue\u2019s work integrates into. Null clears it, so the issue inherits from its chain, then from the project default.")
 });
 var ISSUE_SUMMARY_MAX = 350;
 function inPlainWords(schema, field) {
@@ -16103,16 +16128,35 @@ var setStatusInputSchema = external_exports.strictObject({
 var WORK_CONTEXT_COMMENT_LIMIT = 20;
 var ISSUE_BODY_CHAR_LIMIT = 1e5;
 var ISSUE_COMMENT_LIMIT = 50;
+var crossCuttingModeSchema = external_exports.enum(["full", "keys"]);
+var ISSUE_LIST_LIMIT = 50;
+var issueListDetailSchema = external_exports.enum(["summary", "header"]);
 var issueReadWindowSchema = external_exports.strictObject({
   bodyOffset: nonNegativeIntSchema.optional(),
   bodyLimit: positiveIntSchema.optional(),
   commentOffset: nonNegativeIntSchema.optional(),
-  commentLimit: positiveIntSchema.optional()
+  commentLimit: positiveIntSchema.optional(),
+  /**
+   * How much of the cross-cutting requirements to carry (PIPE-482). It rides HERE
+   * rather than on a schema of its own because it is the same kind of thing as the
+   * four above — a caller saying how much of the record it needs — and both surfaces
+   * that parse this object are the two that must accept it. Omitted means `full`,
+   * resolved server-side, so a caller that says nothing reads what it always read.
+   *
+   * IT CARRIES A `.describe()`, unlike the four sibling window fields, for the reason the
+   * refused header fields above carry theirs: this one is an ENUM whose two members read
+   * as interchangeable from the schema alone, and the JSON Schema is what an agent has in
+   * front of it when it decides which to pass. `bodyOffset` and its siblings name
+   * themselves; `keys` does not say what it drops.
+   */
+  crossCutting: crossCuttingModeSchema.describe("`full` (the default) carries each cross-cutting requirement body; `keys` omits them.").optional()
 });
 var getIssueInputSchema = external_exports.strictObject({
   issue: issueRefSchema,
   ...issueReadWindowSchema.shape
 });
+var WORK_CONTEXT_AVAILABLE_LIMIT = 25;
+var WORK_CONTEXT_AVAILABLE_LIMIT_MAX = 200;
 var getWorkContextInputSchema = external_exports.strictObject({
   issue: issueRefSchema.optional(),
   project: projectRefSchema.optional(),
@@ -16126,7 +16170,34 @@ var getWorkContextInputSchema = external_exports.strictObject({
    * exception and buy nothing, since naming a session cannot change what an item read
    * returns.
    */
-  session: sessionIdSchema.optional()
+  session: sessionIdSchema.optional(),
+  /**
+   * How much of the cross-cutting requirements to carry (PIPE-482), accepted on BOTH
+   * forms for the reason `session` is accepted on both: a session that holds them
+   * passes this on every read it makes, and making one call the exception buys
+   * nothing. Omitted means `full`.
+   */
+  crossCutting: crossCuttingModeSchema.optional(),
+  /**
+   * How many rows of `available` the PROJECT form returns (PIPE-483), defaulting to
+   * {@link WORK_CONTEXT_AVAILABLE_LIMIT} and bounded at {@link
+   * WORK_CONTEXT_AVAILABLE_LIMIT_MAX}. The tool description has named this field as
+   * the applied cap since PIPE-282 while the schema refused it as an unknown key, so a
+   * caller that read the description and passed it was told the key does not exist.
+   *
+   * Accepted on both forms, like `session` above and for the same reason: naming a cap
+   * cannot change what an ITEM read returns, and refusing it there would make one call
+   * the exception.
+   *
+   * IT CARRIES A `.describe()`, like `crossCutting` on {@link issueReadWindowSchema} and
+   * for the same reason: the JSON Schema is what an agent has in front of it when it
+   * decides what to pass, and a bare integer says neither what arrives when it passes
+   * nothing nor how much it may ask for. Both numbers are INTERPOLATED from the
+   * constants they document, so a bound that moves cannot leave the advertised text
+   * claiming the old one. The text also names `availableCount`, because a cap is only
+   * usable beside the total that says whether it was reached.
+   */
+  availableLimit: positiveIntSchema.max(WORK_CONTEXT_AVAILABLE_LIMIT_MAX).describe(`How many rows of \`available\` the project form returns: ${WORK_CONTEXT_AVAILABLE_LIMIT} when omitted, ${WORK_CONTEXT_AVAILABLE_LIMIT_MAX} at most. \`availableCount\` beside the list is the true total.`).optional()
 }).refine((v) => v.issue === void 0 !== (v.project === void 0), {
   message: "pass exactly one of `issue` or `project` \u2014 an issue names its own project, and passing neither names nothing to read"
 });
@@ -16336,6 +16407,13 @@ var listIssuesFilterSchema = external_exports.strictObject({
    * asks — the filter narrows to sessions that said who they were.
    */
   session: sessionIdSchema.optional(),
+  /**
+   * How much of the header each row carries (PIPE-484) — see {@link
+   * issueListDetailSchema}. Omitted means `summary` on every surface: the route
+   * applies that default, so the agent tool and the raw read cannot disagree about
+   * what a bare list returns.
+   */
+  detail: issueListDetailSchema.optional(),
   // Pagination — server default 200, max 500 (§9); default applied server-side.
   limit: external_exports.number().int().min(1, { message: "limit must be at least 1" }).max(500, { message: "limit must be at most 500" }).optional(),
   offset: external_exports.number().int().nonnegative().optional()
@@ -16827,12 +16905,30 @@ var ApiClient = class _ApiClient {
     return this.requestList("GET", "/api/v1/issues", { query: filter });
   }
   /**
-   * Reads the full detail, optionally windowed (PIPE-386): `window`'s four fields ride
+   * The same read as {@link listIssues}, returning the whole envelope (PIPE-484):
+   * `items` plus the true `total` the filter matched and the `next` offset, or null at
+   * the end of the list.
+   *
+   * A SECOND method rather than a widened return on the first, because the two callers
+   * want different things and neither should carry the other's shape. The web renders
+   * rows and pages from `offset: 0`, so a total beside them is nothing it reads; the
+   * agent surface is bounded by a page it did not choose, and there `total` and `next`
+   * are the difference between a first page and a complete answer.
+   */
+  listIssuesPage(filter = {}) {
+    return this.request("GET", "/api/v1/issues", { query: filter });
+  }
+  /**
+   * Reads the full detail, optionally windowed (PIPE-386): `window`'s paging fields ride
    * as the route's query params of the same names, and a response that left anything
    * out carries `omitted` saying so. No window means the WHOLE record — this client
    * injects no default, so the split between the bounded agent surface and the
    * unbounded raw read is decided by the caller that owns it (the MCP handler), not
    * silently here for everyone.
+   *
+   * `window.crossCutting` rides the same way (PIPE-482): `keys` asks for the project's
+   * cross-cutting requirements without their bodies, for a caller that already holds
+   * them and needs only to check the approved revision it has against the current one.
    */
   getIssue(ref, window) {
     return this.request("GET", `/api/v1/issues/${enc(ref)}`, { query: window });
@@ -16845,6 +16941,10 @@ var ApiClient = class _ApiClient {
    * `placement` omits keeps whatever the issue already recorded; the call never clears
    * one. Refused 409 `placement_conflict` when another live claim in the project holds
    * the branch or the worktree.
+   *
+   * Answers with an {@link IssueReceipt}, like the five state-changing writes below it
+   * (PIPE-481): the display id and the fields the call changed, with the whole issue one
+   * {@link ApiClient.getIssue} away.
    */
   claimIssue(ref, placement) {
     return this.request("POST", `/api/v1/issues/${enc(ref)}/claim`, {
@@ -16874,9 +16974,14 @@ var ApiClient = class _ApiClient {
    *
    * `issue` is dropped from the body because the ref rides the path, the way it
    * does on every other whole-value write here.
+   *
+   * Answers with an {@link IssueHeaderReceipt} (PIPE-481) — the ordinary receipt plus
+   * all three texts this call wrote, so the write can be verified from its own answer.
    */
   setIssueHeader(ref, input) {
-    return this.request("PUT", `/api/v1/issues/${enc(ref)}/header`, { body: input });
+    return this.request("PUT", `/api/v1/issues/${enc(ref)}/header`, {
+      body: input
+    });
   }
   /** Records the issue as blocked with a required reason (PIPE-99). */
   setBlocked(ref, reason) {
@@ -17216,6 +17321,17 @@ var ApiClient = class _ApiClient {
   createProject(input) {
     return this.request("POST", "/api/v1/projects", { body: input });
   }
+  /**
+   * Every project this token can see (§7). `detail` chooses the row shape (PIPE-484):
+   * `full` — the default the route applies — is the row with its environments,
+   * milestones and deliverable targets, and `summary` is the chooser's row.
+   *
+   * The return type stays `Project[]`, the full row, because that is what every caller
+   * in this repository that does not pass `detail` receives. A caller asking for
+   * `summary` narrows it itself: `listProjects({ detail: 'summary' }) as ProjectSummary[]`
+   * is the honest cast, and the overload that would express it in the type system would
+   * have to be repeated on every wrapper this client is reached through.
+   */
   listProjects(page) {
     return this.requestList("GET", "/api/v1/projects", { query: page });
   }
@@ -17316,8 +17432,15 @@ var ApiClient = class _ApiClient {
    * answer.
    */
   getWorkContext(input) {
-    return input.issue !== void 0 ? this.request("GET", `/api/v1/issues/${enc(input.issue)}/work-context`) : this.request("GET", `/api/v1/projects/${enc(input.project)}/work-context`, {
-      query: input.session === void 0 ? {} : { session: input.session }
+    const crossCutting = input.crossCutting === void 0 ? {} : { crossCutting: input.crossCutting };
+    return input.issue !== void 0 ? this.request("GET", `/api/v1/issues/${enc(input.issue)}/work-context`, {
+      query: crossCutting
+    }) : this.request("GET", `/api/v1/projects/${enc(input.project)}/work-context`, {
+      query: {
+        ...crossCutting,
+        ...input.session === void 0 ? {} : { session: input.session },
+        ...input.availableLimit === void 0 ? {} : { availableLimit: input.availableLimit }
+      }
     });
   }
   // --- secrets ---------------------------------------------------------------
@@ -17568,6 +17691,8 @@ function safeJsonParse(text) {
 // ../../libs/mcp-server/dist/server.js
 import { AsyncLocalStorage } from "node:async_hooks";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // ../../libs/mcp-server/dist/instructions.js
 var STARTUP_FETCH_TIMEOUT_MS = 5e3;
@@ -17666,7 +17791,7 @@ async function run(body, appended) {
   }
 }
 async function resolveMilestoneId(client2, projectKey, ref) {
-  const projects = await client2.listProjects();
+  const projects = await client2.listProjects({ detail: "full" });
   const project = projects.find((p) => p.key === projectKey);
   if (project === void 0) {
     throw new Error(`No project with key \`${projectKey}\` is visible to this token.`);
@@ -17679,7 +17804,7 @@ async function resolveMilestoneId(client2, projectKey, ref) {
   return match.id;
 }
 async function resolveDeliverableTargetId(client2, projectKey, ref) {
-  const projects = await client2.listProjects();
+  const projects = await client2.listProjects({ detail: "full" });
   const project = projects.find((p) => p.key === projectKey);
   if (project === void 0) {
     throw new Error(`No project with key \`${projectKey}\` is visible to this token.`);
@@ -17691,10 +17816,14 @@ async function resolveDeliverableTargetId(client2, projectKey, ref) {
   }
   return match.id;
 }
-var ORG_ARGUMENT_DESCRIPTION = "The organization this call acts in \u2014 its slug or its uuid. Omitting it is refused unless this session has a default.";
+var ORG_ARGUMENT_DESCRIPTION = "Org slug or uuid; omit only with a session default.";
 var orgArgumentSchema = external_exports.string().min(1).describe(ORG_ARGUMENT_DESCRIPTION).optional();
 function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__ */ new Map(), opts = {}) {
+  return createMcpServerWithRegistry(baseClient, apiBaseUrl, orgInstructions2, opts).server;
+}
+function createMcpServerWithRegistry(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__ */ new Map(), opts = {}) {
   const surface = opts.surface ?? "local";
+  const registry2 = [];
   const scope = new AsyncLocalStorage();
   function client2() {
     return scope.getStore()?.client ?? baseClient;
@@ -17726,6 +17855,12 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     const declared = config3.inputSchema;
     const strict = declared === void 0 ? external_exports.strictObject({}) : "_zod" in declared || "_def" in declared ? declared : external_exports.strictObject(declared);
     const inputSchema = strict.extend({ org: orgArgumentSchema });
+    registry2.push({
+      name,
+      description: config3.description,
+      inputSchema,
+      ...config3._meta === void 0 ? {} : { _meta: config3._meta }
+    });
     server2.registerTool(
       name,
       { ...config3, inputSchema },
@@ -17752,7 +17887,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     );
   }
   registerStrict("list_orgs", {
-    description: "List the organizations this credential may act in, with each name, slug, id, kind and your role. Use it to find the names you may pass. This is the one tool that needs no `org`: every other call names the organization it acts in, and omitting it is refused unless this session has a default. The answer is your memberships right now, so a joined organization appears and a left one does not."
+    description: "List the organizations this credential may act in: name, slug, id, kind and your role. This is the one tool that needs no `org`: every other call names the organization it acts in, and omitting it is refused unless this session has a default. The answer is your memberships right now."
   }, () => (
     // A BARE ARRAY, unlike `list_waiting`'s `{ items }`, and for the reason that tool
     // gives rather than against it: the envelope has already been unwrapped by
@@ -17771,17 +17906,31 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     // makes the tool's own description true.
     run(() => client2().unscoped().listOrgs(), GUIDANCE_POINTER)
   ));
-  registerStrict("list_projects", {
-    description: "List every project: key, environments, milestones (an archived one leaves the pickers, staying valid on issues naming it), deliverable targets and open-issue counts. Pages with `limit` (default 200, max 500) and `offset`.",
-    // Optional pagination (§9) — bounds mirror list_issues/list_requirements; the
-    // server defaults limit to 200 (max 500) and passes limit/offset as query params.
-    inputSchema: {
-      limit: external_exports.number().int().min(1).max(500).optional(),
-      offset: external_exports.number().int().nonnegative().optional()
-    }
-  }, (args) => run(() => client2().listProjects(args), GUIDANCE_POINTER));
+  registerStrict(
+    "list_projects",
+    {
+      description: "List every project: key, name, open-issue count, the active milestone and the placement defaults work falls back to. Summary rows carry no `id`, so chain off `key`; `detail: full` returns the whole project row \u2014 environments, milestones (an archived one stays valid on issues naming it), deliverable targets, and the widget and default fields. Pages with `limit` (default 200, max 500) and `offset`.",
+      // Optional pagination (§9) — bounds mirror list_issues/list_requirements; the
+      // server defaults limit to 200 (max 500) and passes limit/offset as query params.
+      // `detail` is declared INLINE like the rest of this shape: there is no
+      // list-projects schema in @pipeline/domain, so this is where the option lives.
+      inputSchema: {
+        limit: external_exports.number().int().min(1).max(500).optional(),
+        offset: external_exports.number().int().nonnegative().optional(),
+        detail: external_exports.enum(["summary", "full"]).optional()
+      }
+    },
+    // THE AGENT-SURFACE DEFAULT (PIPE-484), injected here — the same deliberate
+    // exception to this side's inject-no-default rule (PIPE-D26) that `get_issue`'s
+    // caps are, and for the same reason: the two surfaces differ by design. A browser
+    // reading this route is rendering a settings page and needs every milestone and
+    // every deliverable target, so the route keeps `full`; an agent reading it is
+    // choosing a project, and was being handed every milestone of every project to do
+    // it. A caller that wants the arrays here says `detail: full` and gets them.
+    (args) => run(() => client2().listProjects({ ...args, detail: args.detail ?? "summary" }), GUIDANCE_POINTER)
+  );
   registerStrict("create_project", {
-    description: "Create a project. Nothing can be filed until one exists. `name` is the display label; `key` is 2\u20135 uppercase letters (e.g. `DWB`), unique per organization, and prefixes every display id.",
+    description: "Create a project. Nothing can be filed until one exists. `name` is the display label; `key` is 2\u20135 uppercase letters, unique per organization, and prefixes every display id.",
     // Inline shape: @pipeline/domain has no standalone create-project schema — the
     // same `{ name, key }` pair lives only inside createOrgInputSchema.project, so
     // this mirrors it exactly (key = 2–5 A–Z via projectKeySchema) and matches
@@ -17792,7 +17941,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     }
   }, (args) => run(() => client2().createProject(args)));
   registerStrict("list_waiting", {
-    description: "Everything not moving on its own across all projects in the organization named by `org`, longest wait first: a requirement revision awaiting approval, an unanswered question, and work at verify holding a criterion that has not passed. Each entry names its project, the ref to act on, and when the wait began. Read-only. A revision clears with `approve_requirement`, a question with `answer_question`, an `auto` criterion with `set_criterion_state`. A criterion marked for human judgment waits for a person."
+    description: "Everything not moving on its own across all projects in the organization named by `org`, longest wait first: a requirement revision awaiting approval, an unanswered question, and work at verify holding a criterion that has not passed. Each entry names its project, the ref to act on, and when the wait began. Read-only. A revision clears with `approve_requirement`, a question with `answer_question`, an `auto` criterion with `set_criterion_state`; one left to human judgment waits for a person."
   }, () => (
     // `{ items }`, mirroring the HTTP envelope rather than unwrapping to a bare array
     // like the sibling list tools. The reason is the envelope itself: this tool is a
@@ -17815,7 +17964,36 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
       // one description loaded into EVERY session by `anthropic/alwaysLoad`. The clauses
       // that went were the ones arguing for the rule rather than stating it; what a caller
       // needs to predict a refusal all stayed.
-      description: "Everything a session needs before starting work. Call it first: it alone returns the doctrine and your organization\u2019s writing rules in full. Pass `issue` or `project`, never both. An issue returns its detail plus each linked requirement\u2019s text, comments capped at `commentLimit` (default " + WORK_CONTEXT_COMMENT_LIMIT + "), with `commentCount` the true total. A project returns `available` \u2014 startable work, excluding done, killed, blocked, person-reserved, others\u2019 claims and, with `session`, your other sessions\u2019 \u2014 capped at `availableLimit` beside the true `availableCount`. Read-only.",
+      //
+      // IT SITS AT THE 80-WORD CAP `plain-descriptions.test.ts` enforces, so a new clause
+      // has to displace an old one. Four suites also demand named tokens in here:
+      // `availableCount` inside a clause that states a cap, and `availableLimit`, from
+      // `work-context-bounds.test.ts`; `done`, `killed` and an exclusion verb from the
+      // e2e AC-9 spec.
+      //
+      // TWO CLAUSES THE SHAPE ITSELF PAID FOR. `item.issue` is no longer the whole issue
+      // read: PIPE-480 moved the cross-cutting requirements onto `project` and the
+      // conventions to the pack's top level, so a description that promised "its detail"
+      // was sending a caller to read two lists off a key that no longer carries them —
+      // `undefined.map`, not an empty list. And `available` arrives in SELECTION ORDER
+      // (PIPE-483): a bounded page is only the right page if the ordering is the server's,
+      // so a caller that re-sorts what it was handed re-sorts one page of the queue.
+      //
+      // THE COMMENT CAP IS A NUMBER AGAIN, AND THAT IS THE POINT. It read "capped at
+      // `commentLimit`", which names a field of the RESPONSE as though it were an argument:
+      // this schema is strict and accepts `issue`, `project`, `session`, `crossCutting` and
+      // `availableLimit`, so a caller that tried to raise the cap was refused for an unknown
+      // key. Interpolating {@link WORK_CONTEXT_COMMENT_LIMIT} says the size of the tail
+      // without offering a knob that does not exist.
+      //
+      // IT AND THE CONVENTIONS CLAUSE WERE PAID FOR BY "active milestone first", which the
+      // cap forced out. The conventions now sit "at the top level" rather than "beside it" —
+      // "it" being the `project` block the clause had just named, so the old words said only
+      // that the conventions were not quite where the sentence had been looking. What went
+      // is the head of the selection order, which is the one clause here a caller cannot act
+      // on differently: "in selection order" already tells it not to re-sort, and which
+      // release leads the order changes nothing it does with the rows.
+      description: "Call it first: it alone returns the doctrine and your organization\u2019s writing rules whole. Pass `issue` or `project`, never both. An issue returns its detail, linked requirements\u2019 text and the newest " + String(WORK_CONTEXT_COMMENT_LIMIT) + " comments (capped; `commentCount` the total); cross-cutting requirements ride on `project`, conventions at the top level. A project returns `available` in selection order, excluding done, killed, blocked, person-reserved, others\u2019 claims and, with `session`, your other sessions\u2019, capped at `availableLimit` beside the true `availableCount`. `crossCutting: keys` drops requirement bodies. Read-only.",
       inputSchema: getWorkContextInputSchema,
       // THE TWO ANNOTATIONS PIPE-D30 REQUIRES, and the reason each key is spelled out
       // rather than built: an unknown `_meta` key is IGNORED — no error, no warning — so a
@@ -17915,7 +18093,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     }
   }, ({ project, target, ...fields }) => run(async () => client2().updateDeliverableTarget(project, await resolveDeliverableTargetId(client2(), project, target), fields)));
   registerStrict("delete_deliverable_target", {
-    description: "Delete a deliverable target by slug or uuid. Only a target with no deliverables can be deleted; one in use is rejected \u2014 deactivate it with `update_deliverable_target` instead.",
+    description: "Delete a deliverable target by slug or uuid. Only one with no deliverables can be deleted; one in use is rejected \u2014 deactivate it with `update_deliverable_target` instead.",
     inputSchema: {
       project: projectKeySchema,
       target: external_exports.string().min(1)
@@ -17928,8 +18106,15 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
   registerStrict(
     "list_issues",
     {
-      description: "List issue summaries \u2014 status, priority, milestone, claimer, criteria progress and the header \u2014 filtered by project, status, type, claimer, priority, milestone, text, parent, blocked, needsHeader and session. With no status filter the default is buildable work: " + OPEN_STATUSES.join(", ") + '. Terminal work is excluded until you name it: pass status ["done","killed"]. An explicit filter is used verbatim, never merged. needsHeader true returns issues whose header is missing or stale; session drops work another session holds.',
-      inputSchema: listIssuesFilterSchema.shape
+      description: "List issue summaries: status, priority, milestone, claimer, criteria progress and the header summary. `detail: header` adds the reason and affected surfaces. " + String(ISSUE_LIST_LIMIT) + " `items` come back by default, beside the true `total` and the `next` offset. With no status filter the default is buildable work: " + OPEN_STATUSES.join(", ") + "; name `done` or `killed` for terminal work. An explicit filter is used verbatim. `session` drops work another session holds; `needsHeader: true` returns issues whose header is missing or stale.",
+      inputSchema: listIssuesFilterSchema.shape,
+      // The same result-threshold annotation `get_work_context` and `get_issue`
+      // declare, spelled out the same way and for the same reason (an unknown `_meta`
+      // key is silently ignored). A long list is where its absence BIT: 157 open issues
+      // measured 161,128 bytes, past the client's own default output cap, so what
+      // reached the session was a truncated list with nothing on it saying rows were
+      // missing. No `alwaysLoad`: that stays the session-start call's alone.
+      _meta: { "anthropic/maxResultSizeChars": WORK_CONTEXT_RESULT_CHARS }
     },
     // The default lives in the API now, not here (PIPE-D35, Listing issues
     // without a status returns only non-terminal work, and the default lives in
@@ -17941,10 +18126,17 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     // and an explicit filter, terminal values and all, is forwarded verbatim as
     // it always was. (The work page kept its terminal rows by naming every
     // status on its reads, so nothing over there leant on the defaultless API.)
-    (args) => run(() => client2().listIssues(args), GUIDANCE_POINTER)
+    //
+    // THE PAGE SIZE IS THE EXCEPTION (PIPE-484), injected here as an explicit `limit`
+    // exactly as `get_issue`'s caps are and for the same reason: the raw HTTP route
+    // keeps its 200 because the web reads there and passes its own limit, while every
+    // response on THIS surface has to land whole. The envelope read — `items`, `total`,
+    // `next` — is what makes a bounded page honest: an agent handed 50 of 157 rows can
+    // see that it was handed 50 of 157.
+    (args) => run(() => client2().listIssuesPage({ ...args, limit: args.limit ?? ISSUE_LIST_LIMIT }), GUIDANCE_POINTER)
   );
   registerStrict("get_issue", {
-    description: "Full issue detail by key or uuid: header, body, criteria, requirement links, cross-cutting requirements, approved conventions, children and comments. `terminal` is true when the issue is done or killed, so it is not buildable; `projectArchived` is true when the project is retired, and this read still answers while lists and writes do not. `headerStale` is true when no header was written or the body moved. Long records page with `bodyOffset` and `commentOffset`; `omitted` and `next` say what was left out.",
+    description: "Full issue detail by key or uuid: header, body, criteria, requirement links, cross-cutting requirements, approved conventions, children and comments. `terminal` is true for done or killed work; `projectArchived` for a retired project, which this read still answers under while lists and writes do not. `headerStale` is true when no header was written or the body moved. `crossCutting: keys` returns the cross-cutting requirements without bodies. Long records page with `bodyOffset` and `commentOffset`; `omitted` and `next` say what was left out.",
     inputSchema: getIssueInputSchema.shape,
     // The same result-threshold annotation `get_work_context` declares, and the same
     // key spelled out for the same reason (an unknown `_meta` key is silently
@@ -17954,7 +18146,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     // reintroduced by a default this server cannot see. No `alwaysLoad`: that stays
     // the session-start call's alone.
     _meta: { "anthropic/maxResultSizeChars": WORK_CONTEXT_RESULT_CHARS }
-  }, ({ issue: issue2, bodyOffset, bodyLimit, commentOffset, commentLimit }) => run(() => (
+  }, ({ issue: issue2, bodyOffset, bodyLimit, commentOffset, commentLimit, crossCutting }) => run(() => (
     // THE AGENT-SURFACE DEFAULTS (PIPE-386), injected here as explicit wire
     // params — the ONE deliberate exception to this side's inject-no-default
     // rule (PIPE-D26), because the two surfaces genuinely differ by design: the
@@ -17964,34 +18156,42 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     // comment tail needs no offset — an omitted `commentOffset` beside a present
     // `commentLimit` IS the newest tail, resolved server-side, so no extra round
     // trip asks how many comments exist (PIPE-R15 rule 4).
+    //
+    // `crossCutting` (PIPE-482) is FORWARDED AND NOT DEFAULTED — the exception
+    // above stays exactly as wide as it was. It exists because a body can grow
+    // past the response ceiling and has to be bounded by somebody; the number of
+    // documents a project flags cross-cutting cannot, so there is nothing here to
+    // protect a caller from, and a default injected on this side would make the
+    // agent surface answer a different question from the route it mirrors.
     client2().getIssue(issue2, {
       bodyOffset,
       bodyLimit: bodyLimit ?? ISSUE_BODY_CHAR_LIMIT,
       commentOffset,
-      commentLimit: commentLimit ?? ISSUE_COMMENT_LIMIT
+      commentLimit: commentLimit ?? ISSUE_COMMENT_LIMIT,
+      crossCutting
     })
   ), GUIDANCE_POINTER));
   registerStrict("create_issue", {
-    description: "Create an epic, task, bug or feedback. Status defaults to triage; anything but triage or killed needs a milestone, else refused `milestone_required`. An archived milestone is refused `milestone_archived_write`. An open issue under a done or killed parent is refused `parent_terminal`. Epics, tasks and bugs carry criteria; feedback is refused `criteria_not_supported`. A `manual` criterion needs `howTo`, else refused `how_to_required`. A bug may name the criterion it was filed against. See the doctrine `get_work_context` returns, under \u201CSearch before you create\u201D.",
+    description: "Create an epic, task, bug or feedback. Status defaults to triage; anything but triage or killed needs a milestone, else refused `milestone_required`. An archived milestone is refused `milestone_archived_write`. An open issue under a done or killed parent is refused `parent_terminal`. Epics, tasks and bugs carry criteria; feedback is refused `criteria_not_supported`. A `manual` criterion needs `howTo`, else refused `how_to_required`. A bug may name the criterion it was filed against. See \u201CSearch before you create\u201D in the doctrine `get_work_context` returns.",
     inputSchema: createIssueInputSchema.shape
   }, (args) => run(() => client2().createIssue(args)));
   registerStrict("promote_feedback", {
-    description: "Retype a feedback report as real work \u2014 an epic or a task \u2014 so it can carry criteria and be built. Feedback itself is refused `criteria_not_supported`. Scheduling the new work into an archived milestone is refused `milestone_archived_write`. Closing the source feedback is refused `status_guard` when anything beneath it, at any depth, is not done or killed. A `manual` criterion needs `howTo`, else refused `how_to_required`. See the doctrine `get_work_context` returns, under \u201CThe bar for filing a bug\u201D.",
+    description: "Retype a feedback report as work that can be built: an epic or a task. Epics, tasks and bugs carry criteria; feedback itself is refused `criteria_not_supported`. Scheduling the new work into an archived milestone is refused `milestone_archived_write`. Closing the source feedback is refused `status_guard` when anything beneath it, at any depth, is not done or killed. A `manual` criterion needs `howTo`, else refused `how_to_required`. See \u201CThe bar for filing a bug\u201D in the doctrine `get_work_context` returns.",
     inputSchema: {
       issue: external_exports.string().min(1),
       ...promoteFeedbackInputSchema.shape
     }
   }, ({ issue: issue2, ...fields }) => run(() => client2().promoteFeedback(issue2, fields)));
   registerStrict("open_review", {
-    description: "Open an epic\u2019s completion review, read by whoever neither built nor evaluated it: one ready task carrying the checklist. Pass exactly one of `epic`, or `project` plus `milestone`. A first call is refused `review_target_not_epic`, `review_target_terminal` (finished epic), `milestone_required` (no milestone), `milestone_not_found` (unknown token). One review per scope; a second is refused `review_already_open`. Epic-form also holds that milestone scope; milestone-form blocks no epic. File findings under the epic, not the review. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Open an epic\u2019s completion review, read by whoever neither built nor evaluated it: one ready task carrying the checklist. Pass exactly one of `epic`, or `project` plus `milestone`. A first call is refused `review_target_not_epic`, `review_target_terminal` (finished epic), `milestone_required` (no milestone), `milestone_not_found` (unknown token). One review per scope; a second is refused `review_already_open`. Epic-form also holds that milestone scope; milestone-form blocks no epic. File findings under the epic, not the review. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: openReviewInputSchema
   }, (args) => run(() => client2().openReview(args)));
   registerStrict("update_issue", {
-    description: "Change an issue\u2019s fields, parent and links. Header fields are refused; `set_criteria` sets criteria, which epics, tasks and bugs carry. An archived milestone is refused `milestone_archived_write`, unless the issue or its parent carries it. A cycle-closing re-parent is refused `parent_cycle`. A finished parent refuses an open issue, `parent_terminal`; a finished one holding open work, `parent_terminal_subtree`. Attaching open work starts a parent that is not blocked, unscheduled or under finished work. See the doctrine `get_work_context` returns, under \u201CMost choices are yours\u201D.",
+    description: "Change an issue\u2019s fields, parent and links. Header fields are refused; `set_criteria` sets criteria, which epics, tasks and bugs carry. An archived milestone is refused `milestone_archived_write`, unless the issue or its parent carries it. A cycle-closing re-parent is refused `parent_cycle`. A finished parent refuses an open issue, `parent_terminal`; a finished one holding open work, `parent_terminal_subtree`. Attaching open work starts a parent that is not blocked, unscheduled or under finished work. See \u201CMost choices are yours\u201D in the doctrine `get_work_context` returns.",
     inputSchema: updateIssueInputSchema.shape
   }, ({ issue: issue2, ...fields }) => run(() => client2().updateIssue(issue2, fields)));
   registerStrict("set_issue_header", {
-    description: "Write an issue\u2019s header \u2014 `summary` (the change in one sentence), `why` (the user, business or cost reason, not the technical one) and `affectedSurfaces` (what this touches and who feels it). All three are required and replace the header whole. Write them in plain words: no identifiers, no file paths, no jargon. A summary shaped like code is refused; `summary` caps at 350 characters. Create and update refuse these fields. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Write an issue\u2019s header \u2014 `summary` (the change in one sentence), `why` (the user, business or cost reason, not the technical one) and `affectedSurfaces` (what this touches and who feels it). All three are required and replace the header whole. Write them in plain words: no identifiers, no file paths, no jargon. A summary shaped like code is refused; `summary` caps at 350 characters. Create and update refuse these fields. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: setIssueHeaderInputSchema.shape
   }, ({ issue: issue2, ...fields }) => run(() => client2().setIssueHeader(issue2, fields)));
   registerStrict("set_status", {
@@ -17999,7 +18199,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: setStatusInputSchema.shape
   }, (args) => run(() => client2().setStatus(args.issue, args.status)));
   registerStrict("claim_issue", {
-    description: "Claim an issue for this session and reserve where the work happens. It succeeds only if unclaimed; under a race one caller wins and the loser is told who holds it. `branch` and `worktree` are refused `placement_conflict` when another live claim in the project holds either, naming that issue. A field you omit keeps what the issue already recorded. Claiming is separate from status, and is refused `reserved_for_person` when an operator has kept the work for a person.",
+    description: "Claim an issue for this session and reserve where the work happens. It succeeds only if unclaimed, and the loser of a race is told who holds it. `branch` and `worktree` are refused `placement_conflict` when another live claim in the project holds either, naming that issue. A field you omit keeps what the issue already recorded. Claiming is separate from status, and is refused `reserved_for_person` when an operator has kept the work for a person.",
     inputSchema: claimInputSchema.shape
   }, ({ issue: issue2, ...placement }) => run(() => client2().claimIssue(issue2, placement)));
   registerStrict("release_issue", {
@@ -18007,15 +18207,15 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: { issue: issueRefSchema }
   }, (args) => run(() => client2().releaseIssue(args.issue)));
   registerStrict("add_comment", {
-    description: "Add a markdown comment to an issue, attributed to the operator and token label. A comment explains a blockage; `set_blocked` and `link_blocker` are what record one. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Add a markdown comment to an issue, attributed to the operator and token label. A comment explains a blockage; `set_blocked` and `link_blocker` are what record one. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: commentInputSchema.shape
   }, (args) => run(() => client2().addComment(args.issue, args.body)));
   registerStrict("set_blocked", {
-    description: "Mark an issue blocked with a required `reason` \u2014 state on the issue, not a comment, and only `clear_blocked` ends it. Setting it again replaces the reason and keeps the old one as history. The reason is a line or two on what the work waits on; what you tried goes in a comment. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Mark an issue blocked with a required `reason` \u2014 state on the issue, not a comment, and only `clear_blocked` ends it. Setting it again replaces the reason and keeps the old one as history. The reason is what the work waits on; what you tried goes in a comment. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: setBlockedInputSchema.shape
   }, (args) => run(() => client2().setBlocked(args.issue, args.reason)));
   registerStrict("clear_blocked", {
-    description: "Clear an issue\u2019s blocked mark. Clearing one that is not blocked is a no-op, not an error. The mark stays as history, and `blocked` on the returned issue is null.",
+    description: "Clear an issue\u2019s blocked mark. Clearing one that is not blocked is a no-op, not an error. The mark stays as history, and the receipt carries `blocked` as null.",
     inputSchema: { issue: issueRefSchema }
   }, (args) => run(() => client2().clearBlocked(args.issue)));
   registerStrict("link_blocker", {
@@ -18023,15 +18223,15 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: linkBlockerInputSchema.shape
   }, (args) => run(() => client2().addBlocker(args.issue, args.blocker)));
   registerStrict("unlink_blocker", {
-    description: "Remove the blocked-by edge between `issue` and `blocker`; one call clears it from both sides. Unlinking a pair that is not linked is a no-op, not an error.",
+    description: "Remove the blocked-by edge between `issue` and `blocker`; one call clears both sides. Unlinking a pair that is not linked is a no-op, not an error.",
     inputSchema: linkBlockerInputSchema.shape
   }, (args) => run(() => client2().removeBlocker(args.issue, args.blocker)));
   registerStrict("set_criteria", {
-    description: "Define or replace the acceptance criteria on an issue. A criterion is one sentence: a concrete situation and what must be true afterward. Epics, tasks and bugs all carry criteria; feedback is refused `criteria_not_supported` \u2014 promote it first. Matched rows keep their AC number; changing text or mode resets state. A `manual` criterion needs `howTo`, else refused `how_to_required`; `howTo` on an `auto` criterion is refused by the schema. See the doctrine `get_work_context` returns, under \u201CChoosing auto or manual\u201D.",
+    description: "Define or replace an issue\u2019s acceptance criteria. A criterion is one sentence: a concrete situation and what must be true afterward. Epics, tasks and bugs all carry criteria; feedback is refused `criteria_not_supported` \u2014 promote it first. Matched rows keep their AC number; changing text or mode resets state. `verification` defaults to `manual`; a `manual` criterion needs `howTo`, else refused `how_to_required`; `howTo` on an `auto` criterion is refused by the schema. See \u201CChoosing auto or manual\u201D in the doctrine `get_work_context` returns.",
     inputSchema: setCriteriaInputSchema.shape
   }, (args) => run(() => client2().setCriteria(args.issue, args.criteria)));
   registerStrict("set_criterion_state", {
-    description: "Set a criterion\u2019s state \u2014 pending, passed or failed \u2014 on an epic, a task or a bug alike. Address it by `criterionId` alone, or by issue plus `criterionNumber`; exactly one form. Feedback never carries criteria, so neither address resolves to one. A token is refused on a manual criterion, which only a person in the browser may set, and a token marking passed or failed must supply evidence. See the doctrine `get_work_context` returns, under \u201CChoosing auto or manual\u201D.",
+    description: "Set a criterion\u2019s state \u2014 pending, passed or failed \u2014 on an epic, a task or a bug alike. Address it by `criterionId` alone, or by issue plus `criterionNumber`; exactly one form. Feedback never carries criteria, so neither address resolves to one. A token is refused on a manual criterion, which only a person in the browser may set, and a token marking passed or failed must supply evidence. See \u201CChoosing auto or manual\u201D in the doctrine `get_work_context` returns.",
     inputSchema: {
       issue: issueRefSchema.optional(),
       criterionId: uuidSchema.optional(),
@@ -18054,19 +18254,19 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     });
   }));
   registerStrict("ask_questions", {
-    description: "Ask the operator questions on an issue. Send them in one call \u2014 a half-asked set costs a second pass. Each question gets a stable `Q-{n}` number, never reused; `options` are the choices you propose. Answers come back on every later read; read them before asking again. Answer one yourself with `answer_question` when your work settles it; withdraw one with `withdraw_question` if it should never have been asked. See the doctrine `get_work_context` returns, under \u201CFile decisions as questions\u201D.",
+    description: "Ask the operator questions on an issue. Send them in one call. Each question gets a stable `Q-{n}` number, never reused; `options` are the choices you propose. Answers come back on every later read; read them before asking again. Answer one yourself with `answer_question` when your work settles it; withdraw one with `withdraw_question` if it should never have been asked. See \u201CFile decisions as questions\u201D in the doctrine `get_work_context` returns.",
     inputSchema: askQuestionsInputSchema.shape
   }, (args) => run(() => client2().askQuestions(args.issue, args.questions)));
   registerStrict("withdraw_question", {
-    description: "Withdraw a question by its `Q-{n}` number, in the organization named by `org`. Only the asker may withdraw, and the asker is the person your credential belongs to, so another agent\u2019s question is not yours to clear. Use it for a question that should never have been asked; one your own work settled deserves `answer_question` instead, which keeps the answer. The question is kept for the audit trail, its number retires, and later reads no longer carry it.",
+    description: "Withdraw a question by its `Q-{n}` number, in the organization named by `org`. Only the asker may withdraw, and the asker is the person your credential belongs to. Use it for a question that should never have been asked; one your own work settled deserves `answer_question`, which keeps the answer. The question is kept for the audit trail, its number retires, and later reads no longer carry it.",
     inputSchema: withdrawQuestionInputSchema.shape
   }, (args) => run(() => client2().withdrawQuestion(args.issue, args.number)));
   registerStrict("answer_question", {
-    description: "Answer a question by its `Q-{n}` number, in the organization named by `org`. Pass exactly one of `option` (a 1-based index into the choices offered) or `text` \u2014 both, or neither, is refused here before anything is sent. Answering again revises; every answer records who answered and which credential. An out-of-range index is refused `option_out_of_range`, naming how many choices there are; a withdrawn or unknown number, `question_not_found`. Answer what your own work settled; leave the rest to the operator.",
+    description: "Answer a question by its `Q-{n}` number. Pass exactly one of `option` (a 1-based index into the choices offered) or `text`; both, or neither, is refused before anything is sent. Answering again revises, and every answer records who answered and which credential. An out-of-range index is refused `option_out_of_range`, naming how many choices there are; a withdrawn or unknown number, `question_not_found`.",
     inputSchema: answerQuestionInputSchema
   }, (args) => run(() => client2().answerQuestion(args.issue, args.number, { option: args.option, text: args.text })));
   registerStrict("list_requirements", {
-    description: "List requirements filtered by project and text: lifecycle (draft/approved/amended), the latest and approved revision numbers, the cross-cutting flag and the linked-epic count.",
+    description: "List requirements filtered by project and text: lifecycle (draft/approved/amended), the latest and approved revision numbers, the cross-cutting flag and the linked-epic count. Up to 200 by default; page with `limit`/`offset`.",
     inputSchema: listRequirementsFilterSchema.shape
   }, (args) => run(() => client2().listRequirements(args), GUIDANCE_POINTER));
   registerStrict("get_requirement", {
@@ -18074,11 +18274,11 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: { requirement: requirementRefSchema, revision: positiveIntSchema.optional() }
   }, (args) => run(() => client2().getRequirement(args.requirement, args.revision), GUIDANCE_POINTER));
   registerStrict("create_requirement", {
-    description: "Create a project-scoped requirement at revision 1 from `title` and `body`. Optional `summary` is a short outline, versioned with them; `area` is a free-text product-area label. The cross-cutting flag makes it bind every epic in the project on its own; never link one explicitly. See the doctrine `get_work_context` returns, under \u201CSearch before you create\u201D.",
+    description: "Create a project-scoped requirement at revision 1 from `title` and `body`. Optional `summary` is a short outline, versioned with them; `area` is a free-text product-area label. The cross-cutting flag makes it bind every epic in the project on its own; never link one explicitly. See \u201CSearch before you create\u201D in the doctrine `get_work_context` returns.",
     inputSchema: createRequirementInputSchema.shape
   }, (args) => run(() => client2().createRequirement(args)));
   registerStrict("update_requirement", {
-    description: "Update a requirement. `title`, `body` and `summary` append a new revision \u2014 nothing is edited in place \u2014 and `note` records why. Area, cross-cutting and decision links are metadata, with no revision. Turning cross-cutting on is rejected while explicit links exist; unlink first. An empty edit is refused (400). See the doctrine `get_work_context` returns, under \u201CLink by key, never paste\u201D.",
+    description: "Update a requirement. `title`, `body` and `summary` append a new revision \u2014 nothing is edited in place \u2014 and `note` records why. Area, cross-cutting and decision links are metadata, with no revision. Turning cross-cutting on is rejected while explicit links exist; unlink first. An empty edit is refused (400). See \u201CLink by key, never paste\u201D in the doctrine `get_work_context` returns.",
     // Inline shape (updateRequirementInputSchema is a refine, no .shape) — add
     // summary/area here explicitly (§210) and decisionLinks (PIPE-84 §6); the
     // empty-edit refine is enforced by the API, not this shape.
@@ -18098,7 +18298,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: approveRequirementInputSchema.shape
   }, (args) => run(() => client2().approveRequirement(args.requirement, args.revision)));
   registerStrict("list_conventions", {
-    description: "List this organization\u2019s conventions \u2014 standing guidance that binds every project here. Returns display id (`CONV-{n}`), title, the standing text, lifecycle and revision numbers. Retired ones are included and marked. `text` matches title and body. Only approved, unretired conventions are delivered to agents.",
+    description: "List this organization\u2019s conventions \u2014 standing guidance that binds every project here: display id (`CONV-{n}`), title, the standing text, lifecycle and revision numbers. Retired ones are included and marked. `text` matches title and body. Only approved, unretired conventions are delivered to agents.",
     inputSchema: listConventionsFilterSchema.shape
   }, (args) => run(() => client2().listConventions(args), GUIDANCE_POINTER));
   registerStrict("get_convention", {
@@ -18110,7 +18310,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: createConventionInputSchema.shape
   }, (args) => run(() => client2().createConvention(args)));
   registerStrict("update_convention", {
-    description: "Amend a convention. `title` and `body` append a new revision \u2014 nothing is edited in place \u2014 and `note` records why. Supplying neither is an empty edit (400). Amended text naming one project is refused as on create. The amendment binds nobody until a person approves it. See the doctrine `get_work_context` returns, under \u201CConventions need a person\u2019s approval\u201D.",
+    description: "Amend a convention. `title` and `body` append a new revision \u2014 nothing is edited in place \u2014 and `note` records why. Supplying neither is an empty edit (400). Amended text naming one project is refused as on create. The amendment binds nobody until a person approves it. See \u201CConventions need a person\u2019s approval\u201D in the doctrine `get_work_context` returns.",
     // Inline shape (updateConventionInputSchema is a refine, so it has no `.shape`);
     // the empty-edit rule is enforced by the API, not by this shape.
     inputSchema: {
@@ -18125,7 +18325,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: listPromptsFilterSchema.shape
   }, (args) => run(() => client2().listPrompts(args), GUIDANCE_POINTER));
   registerStrict("get_prompt", {
-    description: "Get one prompt by display id (`PROMPT-{n}`) or uuid: its current text, which is simply the latest revision, plus every earlier one with who saved it, when and why.",
+    description: "Get one prompt by display id (`PROMPT-{n}`) or uuid: its current text, which is the latest revision, plus every earlier one with who saved it, when and why.",
     inputSchema: { prompt: promptRefSchema }
   }, (args) => run(() => client2().getPrompt(args.prompt), GUIDANCE_POINTER));
   registerStrict("create_prompt", {
@@ -18133,7 +18333,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: createPromptInputSchema.shape
   }, (args) => run(() => client2().createPrompt(args)));
   registerStrict("update_prompt", {
-    description: "Amend a prompt. `title` and `body` append a new revision \u2014 nothing is edited in place \u2014 and `note` records why. `project` moves the attachment and `project: null` detaches it; neither writes a revision. Naming none of the three is an empty edit (400). See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Amend a prompt. `title` and `body` append a new revision \u2014 nothing is edited in place \u2014 and `note` records why. `project` moves the attachment and `project: null` detaches it; neither writes a revision. Naming none of the three is an empty edit (400). See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     // Inline shape (updatePromptInputSchema is a refine, so it has no `.shape`),
     // mirroring that schema's fields — it is the wording this copy follows, `.min(1)`
     // bounds included, so a caller learns a blank body is refused from the advertised
@@ -18148,7 +18348,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     }
   }, ({ prompt, ...fields }) => run(() => client2().updatePrompt(prompt, fields)));
   registerStrict("create_decision", {
-    description: "Record one decision as a project-scoped record (`KEY-D{n}`): `title` names it, `body` says what was decided and why. It starts `proposed` and is frozen once accepted; changing it then means a new record plus `supersede_decision`. See the doctrine `get_work_context` returns, under \u201CA decision record is written once\u201D.",
+    description: "Record one decision as a project-scoped record (`KEY-D{n}`): `title` names it, `body` says what was decided and why. It starts `proposed` and is frozen once accepted; changing it then means a new record plus `supersede_decision`. See \u201CA decision record is written once\u201D in the doctrine `get_work_context` returns.",
     inputSchema: createDecisionInputSchema.shape
   }, (args) => run(() => client2().createDecision(args)));
   registerStrict("get_decision", {
@@ -18156,11 +18356,11 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: getDecisionInputSchema.shape
   }, (args) => run(() => client2().getDecision(args.decision), GUIDANCE_POINTER));
   registerStrict("list_decisions", {
-    description: "List decision records filtered by `project` and `text`: each one\u2019s state, its replacement when superseded, and how many requirements and work items cite it. `text` matches title and body.",
+    description: "List decision records filtered by `project` and `text`: each one\u2019s state, its replacement when superseded, and how many requirements and work items cite it. `text` matches title and body. Up to 200 by default; page with `limit`/`offset`.",
     inputSchema: listDecisionsFilterSchema.shape
   }, (args) => run(() => client2().listDecisions(args), GUIDANCE_POINTER));
   registerStrict("update_decision", {
-    description: "Correct a decision record while it is still `proposed`: `title`, `body`, or both. An edit naming nothing to change is refused here, before anything is sent. Once a record is `accepted` or `superseded` its text is frozen, and the correction is refused `decision_frozen`, which says to write the change as a new record and supersede this one. Use `accept_decision` to accept; asking for `superseded` here is refused, because superseding must name the replacement.",
+    description: "Correct a decision record while it is still `proposed`: `title`, `body`, or both. An edit naming nothing to change is refused before anything is sent. Once a record is `accepted` or `superseded` its text is frozen and the correction is refused `decision_frozen`, which says to write the change as a new record and supersede this one. Use `accept_decision` to accept; asking for `superseded` here is refused, because superseding must name the replacement.",
     inputSchema: updateDecisionInputSchema
   }, (args) => run(() => client2().updateDecision(args.decision, {
     title: args.title,
@@ -18168,7 +18368,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     status: args.status
   })));
   registerStrict("accept_decision", {
-    description: "Accept a decision record that is still `proposed`: it becomes `accepted`, stamped with who accepted it and when, and its text is frozen from then on \u2014 changing it later means a new record plus `supersede_decision`. The tool names the move, so the record is the only argument. A record that is already `accepted` or `superseded` is refused `decision_transition_not_allowed`, naming what it can still do.",
+    description: "Accept a decision record that is still `proposed`: it becomes `accepted`, stamped with who accepted it and when, and its text is frozen from then on \u2014 changing it later means a new record plus `supersede_decision`. A record that is already `accepted` or `superseded` is refused `decision_transition_not_allowed`, naming what it can still do.",
     inputSchema: { decision: decisionRefSchema }
   }, (args) => run(() => client2().updateDecision(args.decision, { status: "accepted" })));
   registerStrict("supersede_decision", {
@@ -18184,19 +18384,19 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: { content: contentRefSchema, revision: positiveIntSchema.optional() }
   }, (args) => run(() => client2().getContent(args.content, args.revision), GUIDANCE_POINTER));
   registerStrict("create_content", {
-    description: "Create a project-scoped content draft at revision 1 from `title` and `body`. Optional `summary` is versioned with them; `area` is a free-text label; `author` is the byline credited on the draft, not the operator calling; `metadata` is stored passively. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Create a project-scoped content draft at revision 1 from `title` and `body`. Optional `summary` is versioned with them; `area` is a free-text label; `author` is the byline credited on the draft, not the operator calling; `metadata` is stored passively. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: createContentInputSchema.shape
   }, (args) => run(() => client2().createContent(args)));
   registerStrict("update_content", {
-    description: "Update a content draft. `title`, `body` or `summary` appends a revision and `note` says why; `area`, `author` and `metadata` are metadata only. An empty edit is refused (400). See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Update a content draft. `title`, `body` or `summary` appends a revision and `note` says why; `area`, `author` and `metadata` are metadata only. An empty edit is refused (400). See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: updateContentInputSchema.shape
   }, ({ content, ...fields }) => run(() => client2().updateContent(content, fields)));
   registerStrict("create_deliverable", {
-    description: "Add a per-platform deliverable to a content draft at revision 1, addressed `DRAFT-KEY/platform`; optional `body` seeds it. `platform` must be one of the project\u2019s active deliverable targets (see `list_projects`); any other slug is rejected. One deliverable per platform per draft; another wording is a revision (`update_deliverable`). See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Add a per-platform deliverable to a content draft at revision 1, addressed `DRAFT-KEY/platform`; optional `body` seeds it. `platform` must be one of the project\u2019s active deliverable targets (see `list_projects` with `detail: full`); any other slug is rejected. One deliverable per platform per draft; another wording is a revision (`update_deliverable`). See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: createDeliverableInputSchema.shape
   }, ({ content, ...fields }) => run(() => client2().createDeliverable(content, fields)));
   registerStrict("update_deliverable", {
-    description: "Append a revision of the post text to a deliverable, addressed `DRAFT-KEY/platform`; `note` says why. The platform itself is immutable. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Append a revision of the post text to a deliverable, addressed `DRAFT-KEY/platform`; `note` says why. The platform itself is immutable. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: updateDeliverableInputSchema.shape
   }, ({ deliverable, ...fields }) => run(() => client2().updateDeliverable(deliverable, fields)));
   registerStrict("record_post", {
@@ -18206,7 +18406,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
   registerStrict("promote_deliverable", {
     // The paste exception is stated because without it an agent holding the doctrine
     // would refuse this tool's whole purpose.
-    description: "Create a NEW issue from a deliverable (`DRAFT-KEY/platform`) with a protected link pinning its current revision, which cannot be removed. Needs `title` and `type`; `status` defaults to triage, `body` seeds the issue. A `status` past triage or killed needs a `milestone`, else refused `milestone_required`. An archived milestone is refused `milestone_archived_write`. Seeding `body` with the post text is the exception to linking rather than pasting. See the doctrine `get_work_context` returns, under \u201CLink by key, never paste\u201D.",
+    description: "Create a NEW issue from a deliverable (`DRAFT-KEY/platform`) with a protected link, which cannot be removed, pinning its current revision. Needs `title` and `type`; `status` defaults to triage, `body` seeds the issue. A `status` past triage or killed needs a `milestone`, else refused `milestone_required`. An archived milestone is refused `milestone_archived_write`. Seeding `body` with the post text is the exception to linking rather than pasting. See \u201CLink by key, never paste\u201D in the doctrine `get_work_context` returns.",
     inputSchema: {
       deliverable: external_exports.string().min(1),
       title: external_exports.string().min(1),
@@ -18243,7 +18443,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
       inputSchema: uploadAssetInputSchema.shape
     }, (args) => run(() => uploadAssetFromPath(client2(), apiBaseUrl, args)));
     registerStrict("download_asset", {
-      description: "Write an ACTIVE asset\u2019s bytes to a local file at `path`, created or overwritten, so you can read an uploaded image or document. Addressed by asset uuid. The bytes are checked against the recorded sha256; the result is metadata and the path.",
+      description: "Write an ACTIVE asset\u2019s bytes to a local file at `path`, created or overwritten. Addressed by asset uuid. The bytes are checked against the recorded sha256; the result is metadata and the path.",
       inputSchema: downloadAssetInputSchema.shape
     }, (args) => run(() => downloadAssetToPath(client2(), args)));
   }
@@ -18256,7 +18456,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     inputSchema: unlinkAssetInputSchema.shape
   }, (args) => run(() => client2().unlinkAsset(args.linkId)));
   registerStrict("set_secret", {
-    description: "Create a secret or add a new version under a project and environment. Do not send a sensitive value here \u2014 it lands in the chat transcript before the server can encrypt it; use `ppb secrets set` from stdin or `--from-file`. `name` is UPPER_SNAKE_CASE, `environment` is a slug (dev/prod). See the doctrine `get_work_context` returns, under \u201CA secret value never travels in a tool call\u201D.",
+    description: "Create a secret or add a new version under a project and environment. Do not send a sensitive value here \u2014 it lands in the chat transcript before the server can encrypt it; use `ppb secrets set` from stdin or `--from-file`. `name` is UPPER_SNAKE_CASE, `environment` is a slug (dev/prod). See \u201CA secret value never travels in a tool call\u201D in the doctrine `get_work_context` returns.",
     inputSchema: {
       project: projectKeySchema,
       environment: external_exports.string().min(1),
@@ -18290,7 +18490,7 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     }
   }, ({ project, environment, name, value }) => run(() => client2().rotateSecret(project, name, { env: environment, value })));
   registerStrict("update_secret_description", {
-    description: "Change a secret\u2019s description \u2014 metadata only: no new version, and nothing here returns a value. See the doctrine `get_work_context` returns, under \u201CHow to write here\u201D.",
+    description: "Change a secret\u2019s description \u2014 metadata only: no new version, and nothing here returns a value. See \u201CHow to write here\u201D in the doctrine `get_work_context` returns.",
     inputSchema: {
       project: projectKeySchema,
       environment: external_exports.string().min(1),
@@ -18313,14 +18513,22 @@ function createMcpServer(baseClient, apiBaseUrl, orgInstructions2 = /* @__PURE__
     description: "List this organization\u2019s agent instructions, one per scope \u2014 the texts composed into the guidance `get_work_context` returns. What is saved here may be newer than what your session composed at startup."
   }, () => run(() => client2().listOrgInstructions(), GUIDANCE_POINTER));
   registerStrict("set_org_instruction", {
-    description: "Set one scope\u2019s organization-level agent instruction, up to 4000 characters; over that is refused, not truncated. Scopes are `general`, `requirements`, `content` and `work.<type>`. It writes the organization this call acts in, so passing `org` rewrites that organization\u2019s standing instructions to every agent working there. It needs the ADMIN role there, so a contributor is refused. New sessions pick it up; running ones keep what they started with. See the doctrine `get_work_context` returns, under \u201CSetting an instruction replaces the whole body\u201D.",
+    description: "Set one scope\u2019s organization-level agent instruction, replacing that scope\u2019s body whole; over 4000 characters is refused, not truncated. Scopes are `general`, `requirements`, `content` and `work.<type>`. It writes the organization this call acts in, so passing `org` rewrites that organization\u2019s standing instructions to every agent working there. It needs the ADMIN role there. New sessions pick it up; running ones keep what they started with. See \u201CSetting an instruction replaces the whole body\u201D in the doctrine `get_work_context` returns.",
     inputSchema: setOrgInstructionInputSchema.shape
   }, (args) => run(() => client2().setOrgInstruction(args.scope, args.body)));
   registerStrict("delete_org_instruction", {
-    description: "Clear one scope\u2019s organization-level agent instruction, in the organization named by `org` \u2014 so this removes that organization\u2019s standing instruction to every agent working there. Clearing a scope that is already unset is an error naming it. It needs the ADMIN role in that organization, so a contributor is refused. New sessions pick up the change; running ones keep what they started with.",
+    description: "Clear one scope\u2019s organization-level agent instruction, in the organization named by `org` \u2014 so this removes that organization\u2019s standing instruction to every agent working there. Clearing a scope that is already unset is an error naming it. It needs the ADMIN role in that organization. New sessions pick up the change; running ones keep what they started with.",
     inputSchema: deleteOrgInstructionInputSchema.shape
   }, (args) => run(() => client2().deleteOrgInstruction(args.scope)));
-  return server2;
+  const advertised = registry2.map(({ name, description, inputSchema, _meta }) => {
+    const { $schema: _draft07, ...jsonSchema } = toJsonSchemaCompat(inputSchema, {
+      strictUnions: true,
+      pipeStrategy: "input"
+    });
+    return _meta === void 0 ? { name, description, inputSchema: jsonSchema } : { name, description, inputSchema: jsonSchema, _meta };
+  });
+  server2.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: advertised }));
+  return { server: server2, registry: registry2 };
 }
 
 // src/main.ts
@@ -18386,7 +18594,7 @@ function loadMcpConfig() {
 }
 
 // src/version.ts
-var VERSION = "0.53.1";
+var VERSION = "0.54.0";
 
 // src/main.ts
 async function scopedClient(base, org) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pipebrain-mcp",
-  "version": "0.53.1",
+  "version": "0.54.0",
   "description": "Pipebrain MCP server for Claude Code and Claude Desktop — issues, requirements, decision records, conventions, prompts, content, assets, metadata-only secrets, and more of the platform's modules over the Pipebrain API.",
   "type": "module",
   "license": "MIT",