@taiga-ai/mcp-server 0.24.0-rc.462 → 0.25.0-dev.465

package/src/server.integration.test.ts

@@ -66,15 +66,12 @@ const ALL_TOOL_NAMES = [
   'taiga_ignore_finding',
   'taiga_link_repository',
   'taiga_list_action_required',
-  'taiga_list_documents',
   'taiga_list_environments',
   'taiga_list_factories',
-  'taiga_list_factory_documents',
   'taiga_list_findings',
   'taiga_list_initiatives',
   'taiga_list_knowledge',
   'taiga_list_linkable_repositories',
-  'taiga_list_product_documents',
   'taiga_list_product_repositories',
   'taiga_list_products',
   'taiga_list_repository_branches',
@@ -326,9 +323,7 @@ describe('MCP server integration', () => {
       const names = toolNames(tools);
 
       expect(names).toContain('taiga_list_factories');
-      expect(names).toContain('taiga_list_factory_documents');
       expect(names).toContain('taiga_get_factory_document');
-      expect(names).not.toContain('taiga_list_documents');
       expect(names).not.toContain('taiga_update_document');
     });
 
@@ -338,7 +333,6 @@ describe('MCP server integration', () => {
       const { tools } = await client.listTools();
       const names = toolNames(tools);
 
-      expect(names).toContain('taiga_list_documents');
       expect(names).toContain('taiga_get_document');
       expect(names).not.toContain('taiga_update_document');
     });
@@ -399,9 +393,7 @@ describe('MCP server integration', () => {
 
       // teams:read tools present
       expect(names).toContain('taiga_list_factories');
-      expect(names).toContain('taiga_list_factory_documents');
       // tenant:documents:read tools present
-      expect(names).toContain('taiga_list_documents');
       // write tools absent
       expect(names).not.toContain('taiga_update_document');
     });
@@ -438,7 +430,6 @@ describe('MCP server integration', () => {
         'taiga_list_products',
         'taiga_get_product',
         'taiga_get_product_context',
-        'taiga_list_product_documents',
         'taiga_get_product_document',
         'taiga_list_runs',
         'taiga_get_run',
@@ -467,8 +458,8 @@ describe('MCP server integration', () => {
       ],
       'vcs:manage': ['taiga_link_repository', 'taiga_set_repository_branch', 'taiga_unlink_repository'],
       'backlog:read': ['taiga_list_initiatives', 'taiga_get_initiative', 'taiga_get_plan', 'taiga_wait_for_initiative'],
-      'factories:read': ['taiga_list_factories', 'taiga_list_factory_documents', 'taiga_get_factory_document'],
-      'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document'],
+      'factories:read': ['taiga_list_factories', 'taiga_get_factory_document'],
+      'tenant:documents:read': ['taiga_get_document'],
       'customDocuments:read': ['taiga_list_knowledge', 'taiga_get_knowledge'],
     };
     const PAIRED_CONTRACT: Record<string, string[]> = {
@@ -562,7 +553,7 @@ describe('MCP server integration', () => {
         routes: { 'GET /v1/tenants/current/documents': { data: [doc], nextCursor: null } },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_documents', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_get_document', arguments: {} });
 
       expect(parseToolResult(result).data).toEqual([
         {
@@ -1292,7 +1283,7 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_list_product_documents',
+        name: 'taiga_get_product_document',
         arguments: { productId: PRODUCT_ID },
       });
 
@@ -1426,7 +1417,7 @@ describe('MCP server integration', () => {
         arguments: { productId: PRODUCT_ID, type: 'architecture' },
       });
       const list = await client.callTool({
-        name: 'taiga_list_product_documents',
+        name: 'taiga_get_product_document',
         arguments: { productId: PRODUCT_ID },
       });
 
@@ -1565,7 +1556,7 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_list_product_documents',
+        name: 'taiga_get_product_document',
         arguments: { productId: PRODUCT_ID },
       });
 
@@ -1604,7 +1595,7 @@ describe('MCP server integration', () => {
       });
 
       const parsed = parseToolResult(
-        await client.callTool({ name: 'taiga_list_product_documents', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_product_document', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(parsed.plan[0].outdated).toBe(false);
@@ -1623,7 +1614,7 @@ describe('MCP server integration', () => {
       });
 
       const parsed = parseToolResult(
-        await client.callTool({ name: 'taiga_list_product_documents', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_product_document', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(parsed.plan[0]).not.toHaveProperty('outdated');
@@ -1642,7 +1633,7 @@ describe('MCP server integration', () => {
       });
 
       const list = parseToolResult(
-        await client.callTool({ name: 'taiga_list_product_documents', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_product_document', arguments: { productId: PRODUCT_ID } })
       );
       const miss = parseToolResult(
         await client.callTool({
@@ -1941,7 +1932,7 @@ describe('MCP server integration', () => {
         nextCursor: null,
       },
       [`GET /v1/products/${PRODUCT_ID}/repositories`]: { data: [repo], nextCursor: null },
-      [`GET /v1/products/${PRODUCT_ID}/builds?limit=10`]: { data: [run], nextCursor: null },
+      [`GET /v1/products/${PRODUCT_ID}/builds?limit=5`]: { data: [run], nextCursor: null },
       [`GET /v1/products/${PRODUCT_ID}/inbox`]: {
         data: [
           { id: 'i1', kind: 'review_pr', status: 'open' },
@@ -2003,7 +1994,7 @@ describe('MCP server integration', () => {
       });
       expect(bundle.documents.architecture).toBeNull();
       expect(bundle.documents.notes).toEqual([
-        'No published plan architecture; taiga_list_product_documents shows what the product has.',
+        'No published plan architecture; taiga_get_product_document without type shows what the product has.',
       ]);
       expect(bundle.policies).toEqual([{ type: 'policy_security', name: 'Security Policy', version: 3, sections: 2 }]);
       expect(bundle.initiatives.items.map((row: { id: string }) => row.id)).toEqual([ITEM_ID]);
@@ -2026,9 +2017,9 @@ describe('MCP server integration', () => {
       });
       expect(bundle.runs).toEqual([
         {
+          // The disposition says how it ended; status, the raw word, is taiga_get_run's (PRO-2800).
           id: BUILD_ID,
           runNumber: 1,
-          status: 'completed',
           targetTitle: 'Add login',
           disposition: 'unmerged',
           outcome: 'Settled without a merged pull request.',
@@ -2364,13 +2355,7 @@ describe('MCP server integration', () => {
     it.each([
       ['taiga_list_factories', {}, '/v1/factories', ['factories:read']],
       ['taiga_list_products', {}, '/v1/products', ['products:read']],
-      ['taiga_list_documents', {}, '/v1/tenants/current/documents', ['tenant:documents:read']],
-      [
-        'taiga_list_factory_documents',
-        { factoryId: FACTORY_ID },
-        `/v1/factories/${FACTORY_ID}/documents`,
-        ['factories:read'],
-      ],
+      ['taiga_get_document', {}, '/v1/tenants/current/documents', ['tenant:documents:read']],
       [
         'taiga_list_initiatives',
         { productId: PRODUCT_ID, status: 'all' },
@@ -2567,7 +2552,7 @@ describe('MCP server integration', () => {
       expect(String((own as Error).message)).toContain('403 FORBIDDEN: Not a member of this product');
       expect(named).toMatchObject({ code: -32602 });
       expect(String((named as Error).message)).toContain(
-        'taiga_list_product_documents shows what exists (403 FORBIDDEN'
+        'taiga_get_product_document without type shows what exists (403 FORBIDDEN'
       );
     });
 
@@ -2640,7 +2625,7 @@ describe('MCP server integration', () => {
       [`GET /v1/products/${PRODUCT_ID}/backlog?status=backlog&limit=100`]: { data: [], nextCursor: null },
       [`GET /v1/products/${PRODUCT_ID}/backlog?status=in_progress&limit=100`]: { data: [item], nextCursor: null },
       [`GET /v1/products/${PRODUCT_ID}/repositories`]: { data: [], nextCursor: null },
-      [`GET /v1/products/${PRODUCT_ID}/builds?limit=10`]: { data: [], nextCursor: null },
+      [`GET /v1/products/${PRODUCT_ID}/builds?limit=5`]: { data: [], nextCursor: null },
       'GET /v1/products?slug=web&limit=1': { data: [product], nextCursor: null },
     };
 
@@ -2731,7 +2716,9 @@ describe('MCP server integration', () => {
         .catch((e: unknown) => e);
 
       expect(failure).toMatchObject({ code: -32602 });
-      expect(String((failure as Error).message)).toContain('taiga_list_products shows the ones it can');
+      expect(String((failure as Error).message)).toContain(
+        'taiga_list_products (query finds one by name) shows the ones it can; a slug or git remote URL names one too.'
+      );
     });
 
     it('should refuse a session with no product named', async () => {
@@ -8427,7 +8414,7 @@ describe('what the sixth agent review found (PRO-2800)', () => {
     expect(plan.summary.length).toBeLessThan(240);
     expect(doc).not.toHaveProperty('status');
     expect(doc).not.toHaveProperty('blocking');
-    expect(doc.readWith).toBe('taiga_list_product_documents (productId)');
+    expect(doc.readWith).toBe('taiga_get_product_document (productId, no type)');
     expect(plan.blocking).toBe(true);
     expect(plan.readWith).toBe('taiga_get_plan (initiativeId: subjectId)');
     expect(task.status).toBe('in_progress');
@@ -8606,6 +8593,9 @@ describe('what the seventh agent review found (PRO-2800)', () => {
     const refused = await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: 'my item' } });
 
     expect(listing).not.toMatch(/"pattern":"\^\(\[0-9a-fA-F\]\{8\}/);
+    // Nor the date-time one: a pattern left is a short one that says something (a slug, a file extension).
+    const patterns = [...listing.matchAll(/"pattern":"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1]!);
+    expect(patterns.filter((pattern) => pattern.length > 60)).toEqual([]);
     expect(listing).toMatch(/"format":"uuid"/);
     expect(JSON.stringify(refused.content)).toMatch(/An initiative ID is a UUID/);
   });
@@ -8813,4 +8803,100 @@ describe('what the seventh agent review found (PRO-2800)', () => {
     expect(critical).not.toHaveProperty('totalNote');
     expect(secrets).not.toHaveProperty('totalNote');
   });
+
+  it('reads a document by type and lists them without one, refusing sections with nothing to read', async () => {
+    const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
+
+    const company = parseToolResult(await client.callTool({ name: 'taiga_get_document', arguments: { sections: [] } }));
+    const product = parseToolResult(
+      await client.callTool({
+        name: 'taiga_get_product_document',
+        arguments: { productId: PRODUCT_ID, origin: 'plan' },
+      })
+    );
+
+    expect(company).toMatchObject({ error: 'VALIDATION_ERROR' });
+    expect(product).toMatchObject({ error: 'VALIDATION_ERROR' });
+  });
+
+  it("keeps a run's hardening note in the compact context row", async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        [`GET /v1/products/${PRODUCT_ID}`]: {
+          data: { id: PRODUCT_ID, name: 'Web', status: 'active', factoryId: FACTORY_ID, settings: {} },
+        },
+        [`/v1/products/${PRODUCT_ID}/builds`]: {
+          data: [
+            {
+              id: BUILD_ID,
+              status: 'completed',
+              prMerged: true,
+              prNumber: 3,
+              hardeningResult: { passed: false, blockingFindings: 2 },
+            },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const bundle = parseToolResult(
+      await client.callTool({ name: 'taiga_get_product_context', arguments: { productId: PRODUCT_ID } })
+    );
+
+    expect(bundle.runs[0].hardeningNote).toMatch(/^Hardening ended with 2 blocking findings/);
+    expect(bundle.runs[0]).not.toHaveProperty('hardeningResult');
+  });
+
+  it('says what the API says when it names the product holding a repository', async () => {
+    const { client, fetchSpy } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`POST /v1/products/${PRODUCT_ID}/repositories`]: refusal(
+          409,
+          'CONFLICT',
+          'taiga-sandbox/import-test-chi is already linked to Orders. A repository belongs to one product; unlink it there first.',
+          { holder: { productId: PRODUCT_ID_2, name: 'Orders' } }
+        ),
+      },
+    });
+
+    const result = parseToolResult(
+      await client.callTool({
+        name: 'taiga_link_repository',
+        arguments: { productId: PRODUCT_ID, linkableRepositoryId: '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f07' },
+      })
+    );
+
+    expect(result.message).toMatch(/already linked to Orders\./);
+    expect(result.details.holder).toEqual({ productId: PRODUCT_ID_2, name: 'Orders' });
+    // No second lookup when the API named it.
+    expect(fetchSpy.mock.calls.some((call: unknown[]) => String(call[0]).includes('/v1/products?'))).toBe(false);
+  });
+
+  it('passes on the product holding a linked repository when the API names it', async () => {
+    const INSTALL = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f0b';
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        'GET /v1/github/installations': { data: [{ id: INSTALL, accountLogin: 'acme' }], nextCursor: null },
+        [`/v1/github/installations/${INSTALL}/repositories`]: {
+          data: [
+            {
+              id: '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f0c',
+              fullName: 'acme/web',
+              linked: true,
+              linkedProduct: { id: PRODUCT_ID_2, name: 'Orders' },
+            },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const result = parseToolResult(await client.callTool({ name: 'taiga_list_linkable_repositories', arguments: {} }));
+
+    expect(result.repositories.data[0].linkedProduct).toEqual({ id: PRODUCT_ID_2, name: 'Orders' });
+  });
 });

package/src/tools/catalogue.test.ts

@@ -102,8 +102,9 @@ describe('tool descriptions against the catalogue', () => {
 
   it('names every policy where the company documents are explained', async () => {
     const tools = await allTools();
-    const list = tools.find((t) => t.name === 'taiga_list_documents')!;
+    // One tool lists and reads the company documents.
     const get = tools.find((t) => t.name === 'taiga_get_document')!;
+    const list = get;
     const typeEnum = (get.inputSchema.properties as Record<string, { enum?: string[] }>)['type']!.enum;
 
     for (const type of POLICY_TYPES) {

package/src/tools/catalogue.ts

@@ -182,7 +182,7 @@ export function setupNextStep(
         );
       case 'complete':
         return (
-          'The import is done: review the reality documents (taiga_list_product_documents), then ' +
+          'The import is done: review the reality documents (taiga_get_product_document without type), then ' +
           'taiga_finish_discovery opens the product.'
         );
       case 'failed':

package/src/tools/context.ts

@@ -56,7 +56,7 @@ const REPOSITORY_SUMMARY_FIELDS = [
 ] as const;
 
 /** How many of the latest runs to carry; taiga_list_runs pages the rest. */
-const BUILDS_IN_CONTEXT = 10;
+const BUILDS_IN_CONTEXT = 5;
 
 /** A run as the bundle carries it: enough to say what was built and where; taiga_get_run has the rest. */
 const CONTEXT_BUILD_FIELDS = [
@@ -76,6 +76,8 @@ const CONTEXT_BUILD_FIELDS = [
   'prDraft',
   'reviewEscalation',
   'error',
+  // Read for hardeningNote; the compact row drops it.
+  'hardeningResult',
   'createdAt',
 ] as const;
 
@@ -240,7 +242,7 @@ async function documentsPart(client: TaigaClient, product: WithoutTenant<Product
       }
     } else if (isNotFound(read.reason)) {
       out[type] = null;
-      notes.push(`No published ${origin} ${type}; taiga_list_product_documents shows what the product has.`);
+      notes.push(`No published ${origin} ${type}; taiga_get_product_document without type shows what the product has.`);
     } else throw read.reason;
   });
   return { ...out, notes };
@@ -337,11 +339,29 @@ async function repositoriesPart(links: () => ReturnType<TaigaClient['listProduct
 async function buildsPart(client: TaigaClient, productId: string) {
   const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data as Record<string, unknown>[];
   const states = await initiativeStates(client, rows);
+  // The fields the outcome is made from are read, then the row is cut to what the bundle says: each run with its
+  // two-sentence outcome and every PR field was half the context, repeated by taiga_list_runs (PRO-2800).
   return pickFields(rows, CONTEXT_BUILD_FIELDS)
     .map(readableRow)
-    .map((row) => withInitiativeState(row, states));
+    .map((row) => withInitiativeState(row, states))
+    .map((row) => pickFields([row], CONTEXT_RUN_SAID)[0]!);
 }
 
+/** A run in the bundle: which one, for what, how it ended, and its pull request. taiga_get_run has the rest. */
+const CONTEXT_RUN_SAID = [
+  'id',
+  'runNumber',
+  'backlogItemId',
+  'targetTitle',
+  'disposition',
+  'outcome',
+  // Rare and short, and what the outcome sentence does not say.
+  'failedReasonMeans',
+  'hardeningNote',
+  'prUrl',
+  'createdAt',
+] as const;
+
 /**
  * What waits on a person for this product, counted as taiga_list_action_required's summary counts it (PRO-2800):
  * the reviewing agent called four tools to answer "how does it stand", and two later reviews found this count and
@@ -466,7 +486,7 @@ export function registerContextTools(server: McpServer, client: TaigaClient) {
         'or git remote URL. Returns product (in setup, readiness and next move), factory with its instructions, ' +
         'specification and architecture outlines (section ids, sizes), policies with section counts, open ' +
         "initiatives with a count per board column (byColumn; taiga_list_initiatives status: 'all' has the done " +
-        'and canceled), repositories, the latest ten runs, and counts for Action Required, open findings and ' +
+        'and canceled), repositories, the latest five runs (taiga_list_runs has more), and counts for Action Required, open findings and ' +
         'policy violations. A part that failed is under unavailable, one the key cannot read under notGranted; ' +
         `neither shows as empty. documents: budget returns whole sections up to about ${DOCUMENT_BUDGET / 1000}k ` +
         'characters each, full returns all.',

package/src/tools/documents.ts

@@ -75,7 +75,8 @@ export const sectionContentInput = z
   .describe('The full new Markdown text of the section; it replaces the old text');
 const tenantDocumentType = z
   .enum(TENANT_DOCUMENT_TYPES)
-  .describe(`Document type: a policy (${named(POLICY_TYPES)}) or ${named(OTHER_TENANT_DOCUMENT_TYPES)}`);
+  // The enum lists every type; the description only says which are policies.
+  .describe('Document type: the policy_* ones are policies');
 
 /**
  * The read, save and publish calls for one document scope. The tools are the
@@ -150,52 +151,48 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
   // ── Company-level policy documents ──────────────────────────────────
 
   if (client.hasCapability('tenant:documents:read')) {
-    server.registerTool(
-      'taiga_list_documents',
-      {
-        title: 'List company documents',
-        description:
-          "List the organization's documents as summaries (type, name, description, version, draft state). The " +
-          `${POLICY_TYPES.length} policies (${named(POLICY_TYPES)}) set the security, data privacy, SDLC, ` +
-          'operations, architecture and compliance rules for every product; the others ' +
-          `(${named(OTHER_TENANT_DOCUMENT_TYPES)}) carry goals, standards, voice and standing instructions. ` +
-          'taiga_get_document reads one.',
-        inputSchema: z.object({
-          ...pagination,
-        }),
-        annotations: READ_ONLY,
-      },
-      (params) =>
-        runTool(async () => {
-          const result = await client.listTenantDocuments(params);
-          return toolResult(page(summaries(result.data), result.nextCursor));
-        })
-    );
-
     server.registerTool(
       'taiga_get_document',
       {
         title: 'Get company document',
         description:
-          "Read one of the organization's documents (a policy, goals, standards). Policies are long: pass " +
+          "Read one of the organization's documents by type, or without type list them all (type, name, version, " +
+          `draft state). The ${POLICY_TYPES.length} policies (${named(POLICY_TYPES)}) set the rules for every ` +
+          `product; the others (${named(OTHER_TENANT_DOCUMENT_TYPES)}) carry goals, standards, voice and ` +
+          'instructions. Policies are long: pass ' +
           'sections: [] for the outline, then the section ids you need, or a control id such as SEC-5.1; ' +
           'unknownSections names ids it lacks. A miss says which documents are published and whether a draft ' +
           "exists. A section's source (template, overlay-<id>, cloud-preset:<providers>) and priority (core: every " +
           'organization keeps it) do not change what it requires.',
         inputSchema: z.object({
-          type: tenantDocumentType,
+          type: tenantDocumentType.optional(),
           sections: policySectionsInput,
+          ...pagination,
         }),
         annotations: READ_ONLY,
       },
       (params) =>
         runTool(async () => {
+          // One tool for the list and the read (PRO-2800): the catalogue's weight is the cost every review ranks
+          // first, and a list tool beside each read was the read without a type.
+          if (params.type === undefined) {
+            if (params.sections) return toolError('VALIDATION_ERROR', 'Name the document (type) to read its sections.');
+            const result = await client.listTenantDocuments({ limit: params.limit, cursor: params.cursor });
+            return toolResult(page(summaries(result.data), result.nextCursor));
+          }
+          const type = params.type;
+          if (params.limit !== undefined || params.cursor !== undefined) {
+            return toolError(
+              'VALIDATION_ERROR',
+              'limit and cursor page the list; omit type to list, or drop them to read.'
+            );
+          }
           try {
-            const result = await client.getTenantDocument(params.type);
+            const result = await client.getTenantDocument(type);
             const doc = stripProvenance(result.data);
             return params.sections
-              ? sectionReadResult(doc, params.sections, params.type, {
-                  controlIds: (POLICY_TYPES as readonly string[]).includes(params.type),
+              ? sectionReadResult(doc, params.sections, type, {
+                  controlIds: (POLICY_TYPES as readonly string[]).includes(type),
                 })
               : toolResult(doc);
           } catch (error) {
@@ -203,10 +200,10 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
             // Best effort, each part on its own: a failed lookup must not turn
             // a miss into an outage, nor blank the part that did answer.
             const [draft, all] = await Promise.allSettled([
-              client.getTenantDocumentDraft(params.type),
+              client.getTenantDocumentDraft(type),
               client.listTenantDocuments({ limit: 100 }),
             ]);
-            const parts = [`No published ${params.type}.`];
+            const parts = [`No published ${type}.`];
             if (draft.status === 'fulfilled') {
               parts.push(
                 draft.value.data
@@ -277,28 +274,6 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
   // ── Factory instructions ────────────────────────────────────────────
 
   if (client.hasCapability('factories:read')) {
-    server.registerTool(
-      'taiga_list_factory_documents',
-      {
-        title: 'List factory documents',
-        description:
-          "List a factory's documents, published and draft (isDraft), as summaries (type, name, version). The only " +
-          `type is ${named(FACTORY_DOCUMENT_TYPES)}: standing guidance (domain context, tech preferences, ` +
-          'conventions) for every product in the factory. An empty list means no publication or draft exists. ' +
-          'taiga_get_factory_document reads it.',
-        inputSchema: z.object({
-          factoryId: idInput('factory', 'taiga_list_factories (query finds one by name) gives it'),
-          ...pagination,
-        }),
-        annotations: READ_ONLY,
-      },
-      (params) =>
-        runTool(async () => {
-          const result = await client.listFactoryDocuments(params.factoryId, params);
-          return toolResult(page(summaries(result.data), result.nextCursor));
-        })
-    );
-
     server.registerTool(
       'taiga_get_factory_document',
       {

package/src/tools/inbox.ts

@@ -63,7 +63,7 @@ function readWith(row: Row, backlogRead: boolean): string | undefined {
       const type = /^[^:]+:([a-z_]+):decision:/.exec(String(row['subjectId']))?.[1];
       return type
         ? `taiga_get_product_document (productId, type: ${type}); the decision's text is this row with full: true`
-        : 'taiga_list_product_documents (productId)';
+        : 'taiga_get_product_document (productId, no type)';
     }
     case 'inbox_task':
       return 'taiga_list_setup_tasks (productId)';
@@ -73,7 +73,7 @@ function readWith(row: Row, backlogRead: boolean): string | undefined {
         review_backlog: backlogRead ? 'taiga_list_initiatives (productId)' : undefined,
         review_maintenance: 'taiga_list_findings (productId)',
         review_policy: 'taiga_get_policy_standing (productId)',
-        review_doc: 'taiga_list_product_documents (productId)',
+        review_doc: 'taiga_get_product_document (productId, no type)',
       }[String(row['kind'])];
     default:
       return undefined;
@@ -517,6 +517,8 @@ export function registerInboxTools(server: McpServer, client: TaigaClient) {
         snoozedUntil: z
           .string()
           .datetime()
+          // format: date-time says it; the leap-year pattern beside it ran to hundreds of characters (PRO-2800).
+          .meta({ pattern: undefined })
           .nullable()
           .optional()
           .describe('Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now'),

package/src/tools/maintenance.ts

@@ -209,8 +209,10 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         "List what maintenance sweeps found in a product's repository: dependencies, secrets, insecure code " +
         '(sast) and infrastructure. The first page opens with sweep (open counts, latest sweeps), so an old or ' +
         'failed sweep is not read as an all-clear. Rows: severity, tier (act_now: known exploited; urgent: ' +
-        'likely and serious; elevated: one of the two; routine), location, remediableBy (upstream_only: no fixed ' +
-        'version), breached controls and initiativeId of a fix under way. Omit status for open findings. taiga_get_finding reads one.',
+        'likely and serious; elevated: one of the two; routine), location, remediableBy (coding_agent: a run here ' +
+        'can fix it; upstream_only: the code is in a submodule, so the fix belongs in its own repository), fixable: false ' +
+        'when no fixed version is known yet, breached controls and initiativeId of a fix under way. Omit status ' +
+        'for open findings. taiga_get_finding reads one.',
       inputSchema: z.object({
         productId,
         status: z
@@ -429,6 +431,8 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         expiresAt: z
           .string()
           .datetime({ offset: true })
+          // format: date-time says it; the leap-year pattern beside it ran to hundreds of characters (PRO-2800).
+          .meta({ pattern: undefined })
           .optional()
           .describe('When the ignore lapses and the finding resurfaces if it still exists (ISO 8601, in the future)'),
       }),
@@ -460,8 +464,8 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         "Raise an initiative that fixes a maintenance finding, at the end of the product's line; it ends in a " +
         "pull request a person merges, and the initiative's review gate applies. wholeGroup: true fixes the " +
         'group in one initiative: every open advisory on that package version in one bump, or every location the ' +
-        'same rule flagged. Refused for a secret only in history, anything in a submodule, and remediableBy ' +
-        'upstream_only.',
+        'same rule flagged. Refused for a secret only in history, remediableBy upstream_only (code in a ' +
+        'submodule), and a dependency with no fixed version yet (fixable: false).',
       inputSchema: z.object({
         productId,
         findingId,

package/src/tools/product-documents.ts

@@ -34,7 +34,7 @@ const EDITABLE_TYPES = PRODUCT_DOCUMENT_TYPES.filter((type): type is EditableTyp
 
 const documentType = z
   .enum(EDITABLE_TYPES)
-  .describe('Document type -- taiga_list_product_documents shows which ones the product has');
+  .describe('Document type -- taiga_get_product_document without type shows which ones the product has');
 
 /** The documents a person reviews: the discovery chain, not the snapshot or the product's own instructions. */
 const reviewableType = z