@taiga-ai/mcp-server 0.11.0 → 0.12.0-dev.417

package/src/tools/backlogs.ts

@@ -1,11 +1,17 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import type { TaigaClient } from '../client.js';
-import { INITIATIVE_TRANSITION_STATES, PLAN_REJECTION_COMMENT_MAX_CHARS, PR_CLOSING_STATES } from '@taiga/types';
+import { TaigaApiError, type TaigaClient } from '../client.js';
+import {
+  INITIATIVE_TRANSITION_STATES,
+  PLAN_REJECTION_COMMENT_MAX_CHARS,
+  PR_CLOSING_STATES,
+  resolveAutoBuild,
+} from '@taiga/types';
 import { OPERATE, READ_ONLY, WRITE } from './annotations.js';
 import { pagination, productId } from './inputs.js';
-import { runTool, toolError, toolResult } from './errors.js';
-import { page, pickFields } from './summarize.js';
+import { isNetworkFailure, runTool, toolError, toolResult } from './errors.js';
+import { queueView } from './queue.js';
+import { criteriaCounts, itemRows, page, pickFields } from './summarize.js';
 
 /** What a list row needs to say for the model to pick an item to read in full. */
 export const BACKLOG_SUMMARY_FIELDS = [
@@ -38,6 +44,7 @@ const ITEM_OUTCOME_FIELDS = [
   'planningStatus',
   'needsHumanCause',
   'needsHumanDetail',
+  'autoBuild',
   'archivedAt',
   'lifecycle',
 ] as const;
@@ -57,15 +64,21 @@ const PLAN_STEP_SUMMARY_FIELDS = [
   'createsResources',
 ] as const;
 
-const outcome = (item: unknown) => toolResult(pickFields([item as Record<string, unknown>], ITEM_OUTCOME_FIELDS)[0]);
+/** The outcome fields of an initiative, with how many of its criteria are met. */
+const outcomeOf = (item: unknown) => {
+  const row = item as Record<string, unknown>;
+  return { ...pickFields([row], ITEM_OUTCOME_FIELDS)[0], criteria: criteriaCounts(row) };
+};
+
+const outcome = (item: unknown) => toolResult(outcomeOf(item));
 
 /**
  * Each tool is registered under the capability its route requires, so a
  * key sees exactly what it may call: reads on backlog:read, the create and
  * the board move on backlog:write, queueing on both backlog:write and
  * products:write (the state route checks both for a drop into queue), the
- * resume on products:write alone, as its route is (the item ID it takes
- * also comes back from a create or a queue), and the plan verdicts on
+ * resume and the review gate on products:write alone, as their routes are
+ * (the item ID they take also comes back from a create or a queue), and the plan verdicts on
  * products:write together with backlog:read, because the plan ID they take
  * comes only from the plan read: a key that cannot read plans has nothing
  * to feed them.
@@ -76,6 +89,7 @@ export function registerBacklogTools(server: McpServer, client: TaigaClient) {
   if (may('backlog:write')) registerBacklogWrites(server, client);
   if (may('backlog:write') && may('products:write')) registerQueue(server, client);
   if (may('products:write')) registerResume(server, client);
+  if (may('products:write')) registerReviewGate(server, client);
   if (may('backlog:read') && may('products:write')) registerPlanVerdicts(server, client);
 }
 
@@ -85,8 +99,9 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
     {
       title: 'List backlog items',
       description:
-        "List a product's backlog items (initiatives): titles, category, status and where each one is on the " +
-        'line (backlog, todo, queue, plan, build, done). Use this to find the item you are working on, then ' +
+        "List a product's backlog items (initiatives): titles, category, status, where each one is on the " +
+        'line (backlog, todo, queue, plan, build, done) and criteria, how many of its acceptance criteria are met ' +
+        '(null before it is planned). Use this to find the item you are working on, then ' +
         'read its acceptance criteria and technical context with taiga_get_backlog_item. ' +
         'Archived items are left out unless asked for.',
       inputSchema: {
@@ -109,7 +124,7 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
       runTool(async () => {
         const result = await client.listBacklogItems(params.productId, params);
         return toolResult(
-          page(pickFields(result.data as Record<string, unknown>[], BACKLOG_SUMMARY_FIELDS), result.nextCursor)
+          page(itemRows(result.data as Record<string, unknown>[], BACKLOG_SUMMARY_FIELDS), result.nextCursor)
         );
       })
   );
@@ -250,6 +265,56 @@ function registerBacklogWrites(server: McpServer, client: TaigaClient) {
 /** The columns a drop into starts paid work, which the state route gates on products:write. */
 const LINE_STARTING_STATES: ReadonlySet<string> = new Set(['queue', 'plan']);
 
+/** Whether a failure is the API's (refused, missing, unreachable) rather than a bug here. */
+const isApiFailure = (error: unknown) => error instanceof TaigaApiError || isNetworkFailure(error);
+
+/**
+ * Whether this initiative's plan builds the moment it lands, and which scope
+ * decided it: its own setting, or the product's default when it has none.
+ * Null when the product cannot be read; the outcome then says so instead.
+ */
+async function reviewGate(client: TaigaClient, item: Record<string, unknown>) {
+  const own = typeof item.autoBuild === 'boolean' ? item.autoBuild : null;
+  try {
+    // The product's default answers only when the initiative has no answer of its own.
+    const product =
+      own === null ? ((await client.getProduct(String(item.productId))).data as { autoBuild?: unknown }) : {};
+    // Absent on the product reads as its true default (@taiga/types).
+    const productDefault = typeof product.autoBuild === 'boolean' ? product.autoBuild : true;
+    const builds = resolveAutoBuild({ initiative: own, product: productDefault });
+    return {
+      buildsWithoutReview: builds,
+      decidedBy: own === null ? 'product' : 'initiative',
+      meaning: builds
+        ? 'The plan is built as soon as it lands; nobody reads it first.'
+        : 'The line stops at the plan for a person to approve or reject it (taiga_get_plan, taiga_approve_plan).',
+    };
+  } catch (error) {
+    if (!isApiFailure(error)) throw error;
+    return null;
+  }
+}
+
+/** Where a queued initiative stands in its product's line; null, and the outcome says so, when the queue cannot be read. */
+async function placeInQueue(client: TaigaClient, item: Record<string, unknown>) {
+  try {
+    const view = await queueView(client, String(item.productId), { name: 'blocking' });
+    const entry = view.entries.find((row) => row.backlogItemId === item.id);
+    return { position: entry?.position ?? null, of: view.entries.length, waitingOn: view.waitingOn };
+  } catch (error) {
+    if (!isApiFailure(error)) throw error;
+    return null;
+  }
+}
+
+const autoBuildInput = z
+  .boolean()
+  .nullable()
+  .describe(
+    "false stops the line at this initiative's plan for a person to read it; true builds it as soon as it lands; " +
+      "null follows the product's default"
+  );
+
 function registerQueue(server: McpServer, client: TaigaClient) {
   server.registerTool(
     'taiga_queue_backlog_item',
@@ -258,10 +323,13 @@ function registerQueue(server: McpServer, client: TaigaClient) {
       description:
         'Add an initiative to the product queue, the line the coding agent works: queued initiatives are ' +
         'planned and built one at a time, each advancing when the previous pull request merges. This starts ' +
-        'paid work: a planner run, then (when the plan is approved, or at once if auto-build is on) a coding ' +
-        'run that pushes commits and opens a pull request in the product repository. Ask the person before ' +
-        'calling this. An initiative already in the queue stays where it is unless afterId says where to go; ' +
-        'one being planned or built cannot move (CONFLICT). Returns the initiative with its new state.',
+        'paid work: a planner run, then a coding run that pushes commits and opens a pull request in the product ' +
+        "repository. Whether the plan is built at once or waits for a person is the initiative's review gate: " +
+        "pass autoBuild: false to read the plan before anything is built (the product's default applies " +
+        'otherwise, and the outcome says which it is); the gate is set first and stays set if the move is then ' +
+        'refused. Ask the person before calling this. An initiative already ' +
+        'in the queue stays where it is unless afterId says where to go; one being planned or built cannot move ' +
+        '(CONFLICT). Returns the initiative with its new state, its review gate and its place in the queue.',
       inputSchema: {
         itemId,
         afterId: z
@@ -272,15 +340,62 @@ function registerQueue(server: McpServer, client: TaigaClient) {
           .describe(
             'The queued initiative to follow; null for the head of the queue; omit to append a new entry or leave a queued one where it is'
           ),
+        autoBuild: autoBuildInput
+          .optional()
+          .describe(
+            "Set the initiative's review gate before queueing: false to read the plan first, true to build it at " +
+              'once, null to follow the product; omit to leave the gate as it is'
+          ),
       },
       annotations: OPERATE,
     },
     (params) =>
       runTool(async () => {
+        const { itemId: id, autoBuild, ...placement } = params;
+        // The gate first: set after the move, a plan landing in between
+        // would be built under the old answer.
+        if (autoBuild !== undefined) await client.setAutoBuild(id, autoBuild);
         // The move the web makes: one write that answers with the refreshed
         // item, rather than the queue route plus two reads around it.
-        const { itemId: id, ...placement } = params;
-        return outcome((await client.transitionInitiative(id, { state: 'queue', ...placement })).data);
+        const item = (await client.transitionInitiative(id, { state: 'queue', ...placement })).data as Record<
+          string,
+          unknown
+        >;
+        const [gate, queue] = await Promise.all([reviewGate(client, item), placeInQueue(client, item)]);
+        return toolResult({
+          ...outcomeOf(item),
+          reviewGate: gate,
+          queue,
+          ...(gate && queue
+            ? {}
+            : { note: 'Part of the outcome could not be read; taiga_get_queue and taiga_get_product say the rest.' }),
+        });
+      })
+  );
+}
+
+function registerReviewGate(server: McpServer, client: TaigaClient) {
+  server.registerTool(
+    'taiga_set_auto_build',
+    {
+      title: "Set an initiative's review gate",
+      description:
+        "Set whether an initiative's plan is built as soon as it lands (true) or waits for a person to read it and " +
+        "approve or reject it (false); null follows the product's default. Standing: it applies to every plan the " +
+        'initiative gets, including one being written now. Opening the gate on a plan that is already waiting ' +
+        'starts its build, so ask the person first. Returns the initiative with the gate that now applies.',
+      inputSchema: { itemId, autoBuild: autoBuildInput },
+      annotations: OPERATE,
+    },
+    (params) =>
+      runTool(async () => {
+        const item = (await client.setAutoBuild(params.itemId, params.autoBuild)).data as Record<string, unknown>;
+        const gate = await reviewGate(client, item);
+        return toolResult({
+          ...outcomeOf(item),
+          reviewGate: gate,
+          ...(gate ? {} : { note: "The product's default could not be read; taiga_get_product says it." }),
+        });
       })
   );
 }

package/src/tools/builds.ts

@@ -52,6 +52,37 @@ const NAMED_PRODUCTS = 100;
 
 const buildId = z.string().uuid().describe('Build run ID -- get from taiga_list_builds');
 
+/** A step without its instructions: what it is, how it stands and what it changed. */
+const STEP_SUMMARY_FIELDS = [
+  'stepOrder',
+  'title',
+  'status',
+  'currentPhase',
+  'commitSha',
+  'filesChanged',
+  'verification',
+  'error',
+  'errorClassification',
+  'startedAt',
+  'completedAt',
+] as const;
+
+/** Past this many characters a step's headline is cut; the full read has the rest. */
+const HEADLINE_LIMIT = 600;
+
+/**
+ * The first paragraph of a step's summary: the agent writes its result
+ * there (what changed, which checks passed), and the detail after it.
+ */
+export function summaryHeadline(summary: unknown): string | null {
+  if (typeof summary !== 'string' || !summary.trim()) return null;
+  const first = summary
+    .trim()
+    .split(/\n\s*\n/, 1)[0]!
+    .trim();
+  return first.length > HEADLINE_LIMIT ? `${first.slice(0, HEADLINE_LIMIT).trimEnd()}...` : first;
+}
+
 /**
  * The runs of every product the key can see, each row naming its product.
  * The route carries product ids only; one products read names them, and a
@@ -156,11 +187,19 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
     {
       title: 'Get build run',
       description:
-        'Get one run in full with its steps: what each step was meant to change, what it did change ' +
-        '(commit, files), its status and any error. Use this to pick up where the coding agent stopped, ' +
-        'or to understand the pull request it opened. Its actions list says what it accepts: stop ' +
-        '(taiga_stop_build), resume or retry_from_failed_step (both taiga_resume_build), start_over (web UI only for now).',
-      inputSchema: { buildId },
+        "Get one run with its steps: the run (status, pull request, hardening, metrics) and each step's title, " +
+        'status, commit, files changed, checks, any error and headline, the first paragraph of what the agent ' +
+        "reported. Pass full: true for each step's complete instructions and report, several thousand tokens on " +
+        'a long run. Use this to pick up where the coding agent stopped, or to understand the pull request it ' +
+        'opened. Its actions list says what it accepts: stop (taiga_stop_build), resume or retry_from_failed_step ' +
+        '(both taiga_resume_build), start_over (web UI only for now).',
+      inputSchema: {
+        buildId,
+        full: z
+          .boolean()
+          .optional()
+          .describe("Carry each step's complete instructions and report (default false: a summary)"),
+      },
       annotations: READ_ONLY,
     },
     (params) =>
@@ -171,7 +210,15 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
           client.getBuildRun(params.buildId),
           client.listBuildRunSteps(params.buildId),
         ]);
-        return toolResult({ ...(run.data as Record<string, unknown>), steps: steps.data });
+        if (params.full) return toolResult({ ...(run.data as Record<string, unknown>), steps: steps.data });
+        const rows = steps.data as Record<string, unknown>[];
+        return toolResult({
+          ...(run.data as Record<string, unknown>),
+          steps: pickFields(rows, STEP_SUMMARY_FIELDS).map((step, index) => ({
+            ...step,
+            headline: summaryHeadline(rows[index]!.summary),
+          })),
+        });
       })
   );
 

package/src/tools/context.ts

@@ -5,13 +5,12 @@ import { z } from 'zod';
 import { TaigaApiError, type TaigaClient } from '../client.js';
 import { READ_ONLY } from './annotations.js';
 import { BACKLOG_SUMMARY_FIELDS } from './backlogs.js';
-import { BUILD_SUMMARY_FIELDS } from './builds.js';
 import { POLICY_TYPES, defaultOriginFor, isImportedProduct, type ProductSettingsView } from './catalogue.js';
 import { apiFailureText, isNetworkFailure, networkFailureDetail, runTool, toolError, toolResult } from './errors.js';
 import { productId, remoteUrl, slug } from './inputs.js';
 import { PRODUCT_SUMMARY_FIELDS, resolveProductRef } from './products.js';
-import { instructionsText, sectionsOf, stripProvenance } from './sections.js';
-import { pickFields } from './summarize.js';
+import { budgetSections, instructionsText, isRecord, sectionsOf, stripProvenance } from './sections.js';
+import { itemRows, pickFields } from './summarize.js';
 
 /**
  * One call at the start of a coding session: everything the model would
@@ -38,9 +37,64 @@ const REPOSITORY_SUMMARY_FIELDS = [
 /** How many of the latest runs to carry; taiga_list_builds pages the rest. */
 const BUILDS_IN_CONTEXT = 10;
 
+/** A run as the bundle carries it: enough to say what was built and where; taiga_get_build has the rest. */
+const CONTEXT_BUILD_FIELDS = [
+  'id',
+  'runNumber',
+  'backlogItemId',
+  'targetTitle',
+  'status',
+  'failedReason',
+  'completedSteps',
+  'totalSteps',
+  'prUrl',
+  'prState',
+  'prMerged',
+  'createdAt',
+] as const;
+
+/**
+ * Characters of section text each of the two documents may bring by default.
+ * Two of them plus the rest of the bundle stay well inside the 25k-token
+ * tool result Claude Code accepts (a 67k-character bundle was refused); a
+ * larger product's documents come cut, with the sections left out named.
+ */
+export const DOCUMENT_BUDGET = 12_000;
+
+/**
+ * The document without each section's citations: on a reality document they
+ * are the code evidence behind every claim and as long as the text itself,
+ * which a session's opening read does not need. The full read keeps them.
+ * Says whether any were dropped, so the bundle can tell the reader.
+ */
+function withoutCitations(doc: Record<string, unknown>): { doc: Record<string, unknown>; dropped: boolean } {
+  const sections = isRecord(doc.data) ? sectionsOf(doc.data) : null;
+  if (!sections) return { doc, dropped: false };
+  let dropped = false;
+  const kept = Object.fromEntries(
+    Object.entries(sections).map(([id, section]) => {
+      if (!isRecord(section) || !('citations' in section)) return [id, section];
+      dropped = true;
+      const { citations: _citations, ...rest } = section;
+      return [id, rest];
+    })
+  );
+  return { doc: { ...doc, data: { ...(doc.data as Record<string, unknown>), sections: kept } }, dropped };
+}
+
+/** How much of the two documents the bundle carries. */
+export type DocumentDepth = 'full' | 'budget' | 'sectionIds';
+
 /** Pages of 100 the backlog part follows before it stops and says so. */
 const BACKLOG_PAGE_LIMIT = 10;
 
+/**
+ * Open items the bundle carries, the newest of those read; past this it says truncated and
+ * taiga_list_backlog_items pages the rest. Keeps a product with hundreds of
+ * open initiatives inside the tool result the document budget is sized for.
+ */
+const BACKLOG_IN_CONTEXT = 50;
+
 const PARTS = {
   factory: 'factories:read',
   documents: 'products:read',
@@ -96,11 +150,11 @@ async function factoryPart(client: TaigaClient, factoryId: string) {
 }
 
 /**
- * The specification and architecture from the product's own timeline: in full
- * by default, or as section ids when the caller wants a small bundle. Null,
- * with a note, where unpublished.
+ * The specification and architecture from the product's own timeline: their
+ * whole sections up to a budget by default, in full or as section ids when
+ * asked. Null, with a note, where unpublished.
  */
-async function documentsPart(client: TaigaClient, product: Record<string, unknown>, full: boolean) {
+async function documentsPart(client: TaigaClient, product: Record<string, unknown>, depth: DocumentDepth) {
   const productId = String(product.id);
   const origin = defaultOriginFor(product as ProductSettingsView);
   const reads = await Promise.allSettled(
@@ -112,8 +166,29 @@ async function documentsPart(client: TaigaClient, product: Record<string, unknow
     const read = reads[index]!;
     if (read.status === 'fulfilled') {
       const doc = stripProvenance(read.value.data as Record<string, unknown>);
-      if (full) out[type] = doc;
-      else {
+      if (depth === 'full') out[type] = doc;
+      else if (depth === 'budget') {
+        const lean = withoutCitations(doc);
+        if (lean.dropped) {
+          notes.push(
+            `The ${origin} ${type} leaves out each section's citations (its code evidence); taiga_get_product_document carries them.`
+          );
+        }
+        const cut = budgetSections(lean.doc, DOCUMENT_BUDGET);
+        if (!cut) {
+          // Not made of sections: whole when small, else pointed at.
+          const small = JSON.stringify(lean.doc).length <= DOCUMENT_BUDGET;
+          out[type] = small ? lean.doc : { version: doc.version, sections: null };
+          if (!small)
+            notes.push(`The ${origin} ${type} is not made of sections; read it with taiga_get_product_document.`);
+        } else if (cut.omittedSections.length > 0) {
+          out[type] = { ...cut.doc, omittedSections: cut.omittedSections };
+          notes.push(
+            `The ${origin} ${type} carries the whole sections that fit; read the ones under omittedSections with ` +
+              'taiga_get_product_document, naming them in sections.'
+          );
+        } else out[type] = cut.doc;
+      } else {
         const sections = sectionsOf((doc.data as Record<string, unknown>) ?? {});
         if (sections) out[type] = { version: doc.version, sections: Object.keys(sections) };
         else {
@@ -158,11 +233,13 @@ async function backlogPart(client: TaigaClient, productId: string) {
   // two reads would otherwise appear twice.
   const open = new Map<string, Record<string, unknown>>();
   let truncated = false;
+  let pageCapped = false;
   for (const status of OPEN_BACKLOG_STATUSES) {
     let cursor: string | undefined;
     for (let pageIndex = 0; ; pageIndex += 1) {
       if (pageIndex === BACKLOG_PAGE_LIMIT) {
         truncated = true;
+        pageCapped = true;
         break;
       }
       const result = await client.listBacklogItems(productId, { status, limit: 100, cursor });
@@ -177,7 +254,26 @@ async function backlogPart(client: TaigaClient, productId: string) {
       cursor = result.nextCursor;
     }
   }
-  return { items: pickFields([...open.values()], BACKLOG_SUMMARY_FIELDS), truncated };
+  // One read per status, so the rows arrive grouped by status, not by age.
+  // Ids are UUIDv7, time-ordered: sorted by id, the newest are the last.
+  const rows = [...open.values()].sort((a, b) =>
+    String(a.id) < String(b.id) ? -1 : String(a.id) > String(b.id) ? 1 : 0
+  );
+  if (rows.length > BACKLOG_IN_CONTEXT) truncated = true;
+  return {
+    items: itemRows(rows.slice(-BACKLOG_IN_CONTEXT), BACKLOG_SUMMARY_FIELDS),
+    truncated,
+    // The list pages oldest first and takes no order, so a status past the
+    // page cap was read only up to its oldest items: these are the newest of
+    // what was read, not of the backlog.
+    ...(pageCapped
+      ? {
+          note:
+            `More than ${BACKLOG_PAGE_LIMIT * 100} open items in one status: only the oldest of them were read, so ` +
+            'the newest may be missing here; taiga_list_backlog_items pages the rest.',
+        }
+      : {}),
+  };
 }
 
 /**
@@ -194,13 +290,13 @@ async function repositoriesPart(client: TaigaClient, productId: string) {
 
 async function buildsPart(client: TaigaClient, productId: string) {
   const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data as Record<string, unknown>[];
-  return pickFields(rows, BUILD_SUMMARY_FIELDS);
+  return pickFields(rows, CONTEXT_BUILD_FIELDS);
 }
 
 export async function productContext(
   client: TaigaClient,
   product: Record<string, unknown>,
-  options: { fullDocuments: boolean }
+  options: { documents: DocumentDepth }
 ): Promise<CallToolResult> {
   const productId = String(product.id);
   const granted = (part: Part) => client.hasCapability(PARTS[part]);
@@ -208,7 +304,7 @@ export async function productContext(
 
   const fetchers: Record<Part, () => Promise<unknown>> = {
     factory: () => factoryPart(client, String(product.factoryId)),
-    documents: () => documentsPart(client, product, options.fullDocuments),
+    documents: () => documentsPart(client, product, options.documents),
     policies: () => policiesPart(client),
     backlog: () => backlogPart(client, productId),
     repositories: () => repositoriesPart(client, productId),
@@ -231,14 +327,23 @@ export async function productContext(
     else if (isApiFailure(result.reason)) unavailable[part] = unavailableReason(result.reason);
     else throw result.reason;
   });
-  return toolResult({
+  const result = {
     ...bundle,
     notGranted: notGranted.map((part) => `${part} (needs ${PARTS[part]})`),
     unavailable,
     readNext:
       'Read a policy in full with taiga_get_document, another product document with taiga_get_product_document, ' +
-      'a backlog item with taiga_get_backlog_item and a run with taiga_get_build.',
-  });
+      'a backlog item with taiga_get_backlog_item (taiga_list_backlog_items pages a truncated backlog) and a run ' +
+      'with taiga_get_build.',
+  };
+  // Its own size, so a model can judge what one more read would cost: counted
+  // with the field in place, until the count no longer changes its own length.
+  let characters = JSON.stringify(result, null, 2).length;
+  for (let measured = -1; measured !== characters;) {
+    measured = characters;
+    characters = JSON.stringify({ ...result, characters: measured }, null, 2).length;
+  }
+  return toolResult({ ...result, characters });
 }
 
 export function registerContextTools(server: McpServer, client: TaigaClient) {
@@ -254,17 +359,21 @@ export function registerContextTools(server: McpServer, client: TaigaClient) {
         'every published policy as its section ids, the open backlog items, the linked repositories and the ' +
         'latest runs. Name the product by ID, slug or the git remote URL of the checkout. A part the API refused ' +
         'or failed is named under unavailable with what it said; a part the key cannot read is named under ' +
-        'notGranted; neither is shown as empty. The two documents come in full, which on a large product is ' +
-        'several thousand tokens; pass fullDocuments: false for their section ids only. Call this first, then ' +
-        'read what you need in full.',
+        'notGranted; neither is shown as empty. The two documents bring as many whole sections as fit, about ' +
+        `${DOCUMENT_BUDGET / 1000}k characters each, and name the sections left out (omittedSections) for ` +
+        'taiga_get_product_document to read; fullDocuments: true carries them whole, tens of thousands of ' +
+        'tokens on a large product and more than some clients accept, and false carries their section ids only. ' +
+        'characters says how large the result is. Call this first, then read what you need.',
       inputSchema: {
         productId: productId.optional(),
         slug: slug.optional(),
         remoteUrl: remoteUrl.optional(),
         fullDocuments: z
           .boolean()
-          .default(true)
-          .describe('Carry the specification and architecture in full (default) or as section ids only'),
+          .optional()
+          .describe(
+            'true carries the specification and architecture whole, false as section ids only; omit for the whole sections that fit a budget'
+          ),
       },
       annotations: READ_ONLY,
     },
@@ -272,7 +381,8 @@ export function registerContextTools(server: McpServer, client: TaigaClient) {
       runTool(async () => {
         const resolved = await resolveProductRef(client, params, ['productId', 'slug', 'remoteUrl']);
         if ('refusal' in resolved) return toolError(resolved.refusal.code, resolved.refusal.message);
-        return productContext(client, resolved.product, { fullDocuments: params.fullDocuments });
+        const documents = params.fullDocuments === undefined ? 'budget' : params.fullDocuments ? 'full' : 'sectionIds';
+        return productContext(client, resolved.product, { documents });
       })
   );
 }

package/src/tools/errors.ts

@@ -85,11 +85,11 @@ export async function runTool(handler: () => Promise<CallToolResult>): Promise<C
  * "MCP error -32602:" and the client would prefix it again.
  */
 export class RequestError extends Error {
-  constructor(
-    readonly code: number,
-    message: string
-  ) {
+  readonly code: number;
+
+  constructor(code: number, message: string) {
     super(message);
+    this.code = code;
     this.name = 'RequestError';
   }
 }

package/src/tools/index.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
 import type { TaigaClient } from '../client.js';
 import { registerProductTools } from './products.js';
 import { registerDocumentTools } from './documents.js';
@@ -6,18 +7,45 @@ import { registerBacklogTools } from './backlogs.js';
 import { registerBuildTools } from './builds.js';
 import { registerContextTools } from './context.js';
 import { registerPrompts } from './prompts.js';
+import { registerQueueTools } from './queue.js';
 import { registerResources } from './resources.js';
+import { DEFAULT_WAIT_OPTIONS, registerWaitTools, type WaitOptions } from './wait.js';
+
+/**
+ * Every tool refuses an argument it does not take. A plain object schema
+ * strips one silently: a review note passed to a tool with no place for it
+ * vanished and the call still succeeded, and a misspelt option quietly
+ * became its default. Strict, the call fails with "Unrecognized key" and the
+ * model learns the tool's real shape. Applied here, once, so no tool can be
+ * registered without it.
+ */
+function withStrictInputs(server: McpServer): McpServer {
+  const register = server.registerTool.bind(server) as (...args: unknown[]) => unknown;
+  server.registerTool = ((name: string, config: { inputSchema?: unknown }, callback: unknown) => {
+    const shape = config.inputSchema;
+    const isRawShape = typeof shape === 'object' && shape !== null && !('_zod' in shape);
+    return register(
+      name,
+      isRawShape ? { ...config, inputSchema: z.strictObject(shape as z.ZodRawShape) } : config,
+      callback
+    );
+  }) as unknown as McpServer['registerTool'];
+  return server;
+}
 
 /**
  * Register all MCP tools, resources and prompts based on the API key's effective capabilities.
  * Only tools matching the key's scopes are registered -- the AI assistant
  * never sees tools it can't use.
  */
-export function registerAllTools(server: McpServer, client: TaigaClient): void {
+export function registerAllTools(server: McpServer, client: TaigaClient, options: { wait?: WaitOptions } = {}): void {
+  withStrictInputs(server);
   registerProductTools(server, client);
   registerDocumentTools(server, client);
   registerBacklogTools(server, client);
   registerBuildTools(server, client);
+  registerQueueTools(server, client);
+  registerWaitTools(server, client, options.wait ?? DEFAULT_WAIT_OPTIONS);
   registerContextTools(server, client);
   registerResources(server, client);
   registerPrompts(server, client);