@taiga-ai/mcp-server 0.17.0-dev.441 → 0.18.0-dev.443

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.17.0-dev.441",
+  "version": "0.18.0-dev.443",
   "description": "MCP server for Taiga -- gives AI assistants access to documents and products",
   "type": "module",
   "main": "./dist/index.js",

package/src/client.ts

@@ -434,6 +434,11 @@ export class TaigaClient {
     return this.request<{ data: unknown }>('GET', `/backlog/${seg(itemId)}`, undefined, { signal });
   }
 
+  /** The initiative's history, oldest first: every turn event and audited move, each with who did it. */
+  async listBacklogItemActivity(itemId: string) {
+    return this.request<{ data: unknown[] }>('GET', `/backlog/${seg(itemId)}/activity`);
+  }
+
   /** A person's move on the line board: the column dropped into, and what to follow there. */
   async transitionInitiative(
     itemId: string,
@@ -615,12 +620,16 @@ export class TaigaClient {
     productId?: string | undefined;
     category?: string | undefined;
     resolved?: boolean | undefined;
+    withTotal?: boolean | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
   }) {
     const { productId, ...rest } = opts;
     const path = productId ? `/products/${seg(productId)}/inbox` : '/inbox';
-    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `${path}${query({ ...rest })}`);
+    return this.request<{ data: unknown[]; nextCursor: string | null; totalCount?: number }>(
+      'GET',
+      `${path}${query({ ...rest })}`
+    );
   }
 
   async updateInboxItem(
@@ -633,12 +642,16 @@ export class TaigaClient {
   async listSetupTasks(opts: {
     productId?: string | undefined;
     openOnly?: boolean | undefined;
+    withTotal?: boolean | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
   }) {
     const { productId, ...rest } = opts;
     const path = productId ? `/products/${seg(productId)}/setup-tasks` : '/setup-tasks';
-    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `${path}${query({ ...rest })}`);
+    return this.request<{ data: unknown[]; nextCursor: string | null; totalCount?: number }>(
+      'GET',
+      `${path}${query({ ...rest })}`
+    );
   }
 
   // ---------------------------------------------------------------------------

package/src/server.integration.test.ts

@@ -65,6 +65,7 @@ const ALL_TOOL_NAMES = [
   'taiga_list_backlog_items',
   'taiga_list_builds',
   'taiga_list_documents',
+  'taiga_list_environments',
   'taiga_list_factories',
   'taiga_list_factory_documents',
   'taiga_list_findings',
@@ -446,6 +447,7 @@ describe('MCP server integration', () => {
         'taiga_list_action_required',
         'taiga_list_setup_tasks',
         'taiga_get_deployments',
+        'taiga_list_environments',
         'taiga_get_delivery_metrics',
         'taiga_get_monitoring',
         'taiga_list_product_repositories',
@@ -1973,8 +1975,11 @@ describe('MCP server integration', () => {
         instructionsVersion: 2,
       });
       expect(bundle.documents.origin).toBe('plan');
-      expect(bundle.documents.specification.data.sections.vision).toEqual({ content: 'A web app' });
-      expect(bundle.documents.specification).not.toHaveProperty('derivedFrom');
+      // The outline by default (PRO-2778): each section id with its size, no text.
+      expect(bundle.documents.specification).toEqual({
+        version: spec.version,
+        sections: [{ id: 'vision', characters: 'A web app'.length }],
+      });
       expect(bundle.documents.architecture).toBeNull();
       expect(bundle.documents.notes).toEqual([
         'No published plan architecture; taiga_list_product_documents shows what the product has.',
@@ -2141,17 +2146,20 @@ describe('MCP server integration', () => {
       expect(bundle.backlog.truncated).toBe(true);
     });
 
-    it('should carry the two documents as section ids only when asked for a small bundle', async () => {
+    it('should carry the two documents as their outline when asked for it', async () => {
       const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES, routes: allRoutes });
 
       const bundle = parseToolResult(
         await client.callTool({
           name: 'taiga_get_product_context',
-          arguments: { productId: PRODUCT_ID, fullDocuments: false },
+          arguments: { productId: PRODUCT_ID, documents: 'outline' },
         })
       );
 
-      expect(bundle.documents.specification).toEqual({ version: 3, sections: ['vision'] });
+      expect(bundle.documents.specification).toEqual({
+        version: 3,
+        sections: [{ id: 'vision', characters: 'A web app'.length }],
+      });
       expect(bundle.documents.architecture).toBeNull();
     });
 
@@ -2169,7 +2177,7 @@ describe('MCP server integration', () => {
       const bundle = parseToolResult(
         await client.callTool({
           name: 'taiga_get_product_context',
-          arguments: { productId: PRODUCT_ID, fullDocuments: false },
+          arguments: { productId: PRODUCT_ID, documents: 'outline' },
         })
       );
 
@@ -4717,7 +4725,10 @@ describe('MCP server integration', () => {
     it('should carry the whole sections that fit the budget, skipping one that does not, name the rest and say how large it is', async () => {
       const { client } = await bootMcpPair({ capabilities: ['products:read'], routes: routes(bigSpec) });
 
-      const raw = await client.callTool({ name: 'taiga_get_product_context', arguments: { productId: PRODUCT_ID } });
+      const raw = await client.callTool({
+        name: 'taiga_get_product_context',
+        arguments: { productId: PRODUCT_ID, documents: 'budget' },
+      });
       const bundle = parseToolResult(raw);
 
       // The size it reports is the size of the text it hands over, the field included.
@@ -4732,7 +4743,7 @@ describe('MCP server integration', () => {
       expect(bundle.characters).toBeLessThan(20_000);
     });
 
-    it('should never cut a section: one past the budget alone is named, and fullDocuments carries everything', async () => {
+    it('should never cut a section: one past the budget alone is named, and documents: full carries everything', async () => {
       // The order a jsonb column hands back: shorter ids first, whatever order they were written in.
       const huge = {
         ...bigSpec,
@@ -4741,12 +4752,15 @@ describe('MCP server integration', () => {
       const { client } = await bootMcpPair({ capabilities: ['products:read'], routes: routes(huge) });
 
       const cut = parseToolResult(
-        await client.callTool({ name: 'taiga_get_product_context', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({
+          name: 'taiga_get_product_context',
+          arguments: { productId: PRODUCT_ID, documents: 'budget' },
+        })
       ).documents.specification;
       const full = parseToolResult(
         await client.callTool({
           name: 'taiga_get_product_context',
-          arguments: { productId: PRODUCT_ID, fullDocuments: true },
+          arguments: { productId: PRODUCT_ID, documents: 'full' },
         })
       ).documents.specification;
 
@@ -4756,7 +4770,7 @@ describe('MCP server integration', () => {
       expect(full).not.toHaveProperty('omittedSections');
     });
 
-    it("should leave each section's citations out of the bundle and say so, while fullDocuments keeps them", async () => {
+    it("should leave each section's citations out of the budget bundle and say so, while documents: full keeps them", async () => {
       const cited = {
         ...bigSpec,
         data: { sections: { overview: { ...section('text'), citations: [{ path: 'src/a.rs', lines: '1-9' }] } } },
@@ -4764,12 +4778,15 @@ describe('MCP server integration', () => {
       const { client } = await bootMcpPair({ capabilities: ['products:read'], routes: routes(cited) });
 
       const lean = parseToolResult(
-        await client.callTool({ name: 'taiga_get_product_context', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({
+          name: 'taiga_get_product_context',
+          arguments: { productId: PRODUCT_ID, documents: 'budget' },
+        })
       ).documents;
       const full = parseToolResult(
         await client.callTool({
           name: 'taiga_get_product_context',
-          arguments: { productId: PRODUCT_ID, fullDocuments: true },
+          arguments: { productId: PRODUCT_ID, documents: 'full' },
         })
       ).documents;
 
@@ -4795,10 +4812,37 @@ describe('MCP server integration', () => {
       // The document's own order, whatever order they were asked in.
       expect(Object.keys(doc.data.sections)).toEqual(['flows', 'risks']);
       expect(doc.omittedSections.map((s: { id: string }) => s.id)).toEqual(['overview', 'features']);
-      expect(miss.isError).toBe(true);
-      expect(parseToolResult(miss).message).toBe(
-        'The plan specification has no section nope; its sections are overview, features, flows, risks.'
+      // One shape whatever matched (PRO-2778): none right still answers, listing every real id with its size.
+      expect(miss.isError).toBeFalsy();
+      const missed = parseToolResult(miss);
+      expect(missed.data.sections).toEqual({});
+      expect(missed.unknownSections).toEqual(['nope']);
+      expect(missed.omittedSections.map((s: { id: string }) => s.id)).toEqual([
+        'overview',
+        'features',
+        'flows',
+        'risks',
+      ]);
+    });
+
+    it('should read a product document as its outline with sections: []', async () => {
+      const { client } = await bootMcpPair({ capabilities: ['products:read'], routes: routes(bigSpec) });
+
+      const outline = parseToolResult(
+        await client.callTool({
+          name: 'taiga_get_product_document',
+          arguments: { productId: PRODUCT_ID, type: 'specification', origin: 'plan', sections: [] },
+        })
       );
+
+      expect(outline.data.sections).toEqual({});
+      expect(outline.omittedSections).toEqual([
+        { id: 'overview', characters: 5_000 },
+        { id: 'features', characters: expect.any(Number) },
+        { id: 'flows', characters: 5_000 },
+        { id: 'risks', characters: expect.any(Number) },
+      ]);
+      expect(outline).not.toHaveProperty('unknownSections');
     });
   });
 
@@ -5886,21 +5930,25 @@ describe('MCP server integration', () => {
         })
       );
 
-      expect(linked).toEqual([
-        {
-          id: LINK_ID,
-          provider: 'github',
-          repositoryName: 'acme/billing',
-          repositoryUrl: 'https://github.com/acme/billing',
-          repositoryDefaultBranch: 'main',
-          baseBranch: null,
-          effectiveBranch: 'main',
-          label: null,
-          buildable: true,
-          isManaged: false,
-        },
-      ]);
-      expect(branches.branches).toHaveLength(2);
+      // data, as every list carries its rows (PRO-2778), not a bare array.
+      expect(linked).toEqual({
+        data: [
+          {
+            id: LINK_ID,
+            provider: 'github',
+            repositoryName: 'acme/billing',
+            repositoryUrl: 'https://github.com/acme/billing',
+            repositoryDefaultBranch: 'main',
+            baseBranch: null,
+            effectiveBranch: 'main',
+            label: null,
+            buildable: true,
+            isManaged: false,
+          },
+        ],
+        truncated: false,
+      });
+      expect(branches.data).toHaveLength(2);
       expect(found.accounts).toEqual([{ id: INSTALL_ID, accountLogin: 'acme', accountType: 'Organization' }]);
       expect(found.repositories).toEqual({
         data: [
@@ -5969,12 +6017,71 @@ describe('MCP server integration', () => {
       );
       // The limit holds across accounts, and the answer says it was cut.
       expect(one.repositories.data).toHaveLength(1);
-      expect(one.more).toMatch(/installationId/);
+      expect(one.more).toMatch(/name an account/);
       expect(both.repositories.data.map((r: { fullName: string }) => r.fullName)).toEqual([
         'acme/billing',
         'acme-labs/billing-poc',
       ]);
-      expect(both.more).toMatch(/installationId/);
+      expect(both.more).toMatch(/name an account/);
+    });
+
+    // PRO-2778: the first account's page filled the answer and hid the others.
+    it('should take rows from each account in turn, and read one account by its login', async () => {
+      const three = [1, 2, 3].map((n) => ghRepo(`0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4d0${n}`, `acme/repo-${n}`));
+      const { client, fetchSpy } = await bootMcpPair({
+        capabilities: ['vcs:read'],
+        routes: {
+          'GET /v1/github/installations': {
+            data: [
+              { id: INSTALL_ID, accountLogin: 'acme', accountType: 'Organization' },
+              { id: INSTALL_ID_2, accountLogin: 'taiga-sandbox', accountType: 'Organization' },
+            ],
+            nextCursor: null,
+          },
+          [`GET /v1/github/installations/${INSTALL_ID}/repositories`]: { data: three, nextCursor: null },
+          [`GET /v1/github/installations/${INSTALL_ID_2}/repositories`]: {
+            data: [ghRepo(LINK_ID, 'taiga-sandbox/greenfield')],
+            nextCursor: null,
+          },
+        },
+      });
+
+      const spread = parseToolResult(
+        await client.callTool({ name: 'taiga_list_linkable_repositories', arguments: { limit: 2 } })
+      );
+      expect(spread.repositories.data.map((r: { fullName: string }) => r.fullName)).toEqual([
+        'acme/repo-1',
+        'taiga-sandbox/greenfield',
+      ]);
+
+      const before = calls(fetchSpy, 'GET').length;
+      const sandbox = parseToolResult(
+        await client.callTool({ name: 'taiga_list_linkable_repositories', arguments: { account: 'Taiga-Sandbox' } })
+      );
+      expect(sandbox.repositories.data.map((r: { fullName: string }) => r.fullName)).toEqual([
+        'taiga-sandbox/greenfield',
+      ]);
+      // Only the installations and that one account were read.
+      const urls = calls(fetchSpy, 'GET')
+        .slice(before)
+        .map((u) => u.pathname);
+      expect(urls.some((u) => u.includes(`/installations/${INSTALL_ID}/`))).toBe(false);
+
+      // owner/repo names its owner, a GitHub-length repository name included.
+      const byRepo = parseToolResult(
+        await client.callTool({
+          name: 'taiga_list_linkable_repositories',
+          arguments: { account: `taiga-sandbox/${'r'.repeat(100)}` },
+        })
+      );
+      expect(byRepo.repositories.data).toHaveLength(1);
+
+      const missing = await client.callTool({
+        name: 'taiga_list_linkable_repositories',
+        arguments: { account: 'nope' },
+      });
+      expect(missing.isError).toBe(true);
+      expect(parseToolResult(missing).details.accounts).toHaveLength(2);
     });
   });
 
@@ -6342,10 +6449,12 @@ describe('what the agent review found (PRO-2759)', () => {
       name: 'taiga_get_document',
       arguments: { type: 'policy_security', sections: ['secrets'] },
     });
-    expect(parseToolResult(none)).toEqual({
-      error: 'NOT_FOUND',
-      message: 'The policy_security has no section secrets; its sections are summary, scope.',
-    });
+    // One shape whatever matched (PRO-2778): every real id with its size, the miss named.
+    expect(none.isError).toBeFalsy();
+    const missed = parseToolResult(none);
+    expect(missed.data.sections).toEqual({});
+    expect(missed.unknownSections).toEqual(['secrets']);
+    expect(missed.omittedSections.map((s: { id: string }) => s.id)).toEqual(['summary', 'scope']);
   });
 
   it('says what a product in setup waits for, and warns of a half turned off with nothing said about it', async () => {
@@ -6533,3 +6642,261 @@ describe('what the agent review found (PRO-2759)', () => {
     });
   });
 });
+
+describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
+  const ENV_ID = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a80';
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('says how many need a person on the first page, and asks for the count only there', async () => {
+    const { client, fetchSpy } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        'GET /v1/inbox': { data: [], nextCursor: 'c2', totalCount: 42 },
+        'GET /v1/setup-tasks': { data: [], nextCursor: null, totalCount: 3 },
+      },
+    });
+
+    const inbox = parseToolResult(await client.callTool({ name: 'taiga_list_action_required', arguments: {} }));
+    const tasks = parseToolResult(await client.callTool({ name: 'taiga_list_setup_tasks', arguments: {} }));
+    expect(inbox.totalCount).toBe(42);
+    expect(tasks.totalCount).toBe(3);
+    expect(sentUrl(fetchSpy, '/v1/inbox').searchParams.get('withTotal')).toBe('true');
+    expect(sentUrl(fetchSpy, '/v1/setup-tasks').searchParams.get('withTotal')).toBe('true');
+
+    fetchSpy.mockClear();
+    await client.callTool({ name: 'taiga_list_action_required', arguments: { cursor: 'c2' } });
+    expect(sentUrl(fetchSpy, '/v1/inbox').searchParams.has('withTotal')).toBe(false);
+  });
+
+  it('carries who cancelled a failed plan and when, and leaves the item as it was when the history is refused', async () => {
+    const failed = { id: ITEM_ID, title: 'Login', planningStatus: 'failed', planFailureCause: 'cancelled' };
+    const history = {
+      data: [
+        {
+          kind: 'turn',
+          trigger: 'plan_failed',
+          actor: { type: 'agent', id: null, name: null },
+          occurredAt: '2026-10-01T00:00:00.000Z',
+          data: { cause: 'agent_error' },
+        },
+        {
+          kind: 'audit',
+          action: 'backlog.moved',
+          actor: { type: 'user', id: 'u1', name: 'Ada' },
+          occurredAt: '2026-10-02T00:00:00.000Z',
+          data: null,
+        },
+        {
+          kind: 'turn',
+          trigger: 'plan_failed',
+          actor: { type: 'user', id: 'u1', name: 'Ada' },
+          occurredAt: '2026-10-03T00:00:00.000Z',
+          data: { cause: 'cancelled' },
+        },
+      ],
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: { [`GET /v1/backlog/${ITEM_ID}`]: { data: failed }, [`GET /v1/backlog/${ITEM_ID}/activity`]: history },
+    });
+
+    const item = parseToolResult(
+      await client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+    );
+    expect(item.planFailure).toEqual({
+      cause: 'cancelled',
+      meaning: 'A person stopped the planning (by says who). Ask before planning it again.',
+      at: '2026-10-03T00:00:00.000Z',
+      by: 'Ada',
+    });
+
+    const refused = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: failed },
+        [`GET /v1/backlog/${ITEM_ID}/activity`]: refusal(403, 'FORBIDDEN', 'No'),
+      },
+    });
+    const bare = parseToolResult(
+      await refused.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+    );
+    expect(bare).toEqual(failed);
+
+    // A history whose last failure disagrees with the item is an earlier one: the cause stays, who and when do not.
+    const stale = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: { ...failed, planFailureCause: 'worker_lost' } },
+        [`GET /v1/backlog/${ITEM_ID}/activity`]: history,
+      },
+    });
+    const staleItem = parseToolResult(
+      await stale.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+    );
+    expect(staleItem.planFailure).toEqual({
+      cause: 'worker_lost',
+      meaning: 'Nobody was running the planning any more (the worker stopped). Planning again is the usual next step.',
+      at: null,
+      by: null,
+    });
+
+    // A cancel before the latest plan_started is an earlier attempt's, same cause or not.
+    const retried = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: failed },
+        [`GET /v1/backlog/${ITEM_ID}/activity`]: {
+          data: [
+            ...history.data,
+            {
+              kind: 'turn',
+              trigger: 'plan_started',
+              actor: { type: 'user', id: 'u2', name: 'Bo' },
+              occurredAt: '2026-10-04T00:00:00.000Z',
+              data: null,
+            },
+          ],
+        },
+      },
+    });
+    expect(
+      parseToolResult(await retried.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } }))
+    ).toEqual(failed);
+
+    // No failure in the history, or no history reachable: the item as it is.
+    const silent = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: failed },
+        [`GET /v1/backlog/${ITEM_ID}/activity`]: { data: [history.data[1]] },
+      },
+    });
+    expect(
+      parseToolResult(await silent.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } }))
+    ).toEqual(failed);
+    const offline = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: failed },
+        [`GET /v1/backlog/${ITEM_ID}/activity`]: () =>
+          Promise.reject(new TypeError('fetch failed', { cause: 'ECONNRESET' })),
+      },
+    });
+    expect(
+      parseToolResult(await offline.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } }))
+    ).toEqual(failed);
+
+    // A plan that did not fail reads no history.
+    const planned = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: { [`GET /v1/backlog/${ITEM_ID}`]: { data: { ...failed, planningStatus: 'planned' } } },
+    });
+    await planned.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } });
+    expect(planned.fetchSpy.mock.calls.some((c: unknown[]) => String(c[0]).includes('/activity'))).toBe(false);
+  });
+
+  it("lists a product's environments, and refuses a window the pages do not offer before asking the API", async () => {
+    const { client, fetchSpy } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/products/${PRODUCT_ID}/environments`]: {
+          data: [
+            {
+              id: ENV_ID,
+              name: 'Production',
+              slug: 'prod',
+              type: 'production',
+              ordinal: 2,
+              status: 'active',
+              isProtected: true,
+              url: 'https://x.test',
+              secret: 'no',
+            },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const envs = parseToolResult(
+      await client.callTool({ name: 'taiga_list_environments', arguments: { productId: PRODUCT_ID } })
+    );
+    expect(envs.data).toEqual([
+      {
+        id: ENV_ID,
+        name: 'Production',
+        slug: 'prod',
+        type: 'production',
+        ordinal: 2,
+        status: 'active',
+        isProtected: true,
+        url: 'https://x.test',
+      },
+    ]);
+
+    const odd = await client.callTool({
+      name: 'taiga_get_delivery_metrics',
+      arguments: { productId: PRODUCT_ID, environmentId: ENV_ID, windowDays: 45 },
+    });
+    expect(odd.isError).toBe(true);
+    expect(fetchSpy.mock.calls.some((c: unknown[]) => String(c[0]).includes('/insights'))).toBe(false);
+    const { tools } = await client.listTools();
+    const metrics = tools.find((t) => t.name === 'taiga_get_delivery_metrics')!;
+    const properties = metrics.inputSchema.properties as Record<string, { enum?: unknown }>;
+    expect(properties.windowDays!.enum).toEqual([30, 60, 90]);
+  });
+
+  it('opens every writing tool with what it does, and leaves the reads as they were', async () => {
+    const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
+    const { tools } = await client.listTools();
+
+    for (const tool of tools) {
+      const notes = tool.annotations ?? {};
+      const description = tool.description ?? '';
+      if (notes.readOnlyHint) expect(description, tool.name).not.toMatch(/^(Writes\.|Acts on paid)/);
+      else if (notes.destructiveHint)
+        expect(description, tool.name).toMatch(/^Acts on paid or shared work: ask the person first\. /);
+      else expect(description, tool.name).toMatch(/^Writes\. /);
+    }
+    expect(tools.find((t) => t.name === 'taiga_queue_backlog_item')!.description).toMatch(/^Acts on paid/);
+    expect(tools.find((t) => t.name === 'taiga_create_factory')!.description).toMatch(/^Writes\. /);
+  });
+
+  it("carries each breached control's findings by tier", async () => {
+    const tiers = { act_now: 0, urgent: 0, elevated: 0, routine: 19 };
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/products/${PRODUCT_ID}/maintenance/policies`]: {
+          data: {
+            productId: PRODUCT_ID,
+            hasPolicies: true,
+            controls: [
+              {
+                controlId: 'SEC-3.4',
+                policyType: 'policy_security',
+                text: 'No secrets in code',
+                state: 'breached',
+                findingCount: 19,
+                findingsByTier: tiers,
+                divergenceCount: 0,
+                workItems: [],
+                plannedCount: 0,
+              },
+            ],
+            divergences: [],
+            resolvedDivergences: [],
+          },
+        },
+      },
+    });
+
+    const standing = parseToolResult(
+      await client.callTool({ name: 'taiga_get_policy_standing', arguments: { productId: PRODUCT_ID } })
+    );
+    expect(standing.controls[0].findingsByTier).toEqual(tiers);
+  });
+});

package/src/tools/autonomy.ts

@@ -29,7 +29,7 @@ export function registerAutonomyTools(server: McpServer, client: TaigaClient) {
           'product has room. autoMerge: false makes pull requests wait for a person to merge them; null follows ' +
           "the organization and factory above (autonomous merge needs the organization's switch on, and a factory " +
           'can turn it off for everything under it; neither can be opened from here). Defaults, not rules: an ' +
-          'initiative can decide otherwise for itself. Changes how work proceeds; ask the person first.',
+          'initiative can decide otherwise for itself. Changes how work proceeds.',
         inputSchema: z.object({
           productId,
           autoBuild: z.boolean().optional().describe('Build landed plans without a review by default'),
@@ -70,7 +70,7 @@ export function registerAutonomyTools(server: McpServer, client: TaigaClient) {
           "repository's own rules pass (required checks, reviews, a code reviewer you made Taiga wait for); false " +
           "makes it wait for a person; null follows the product's default. The final word within what the " +
           'organization and factories allow: where either has turned autonomous merge off, true changes nothing. ' +
-          'Taiga merges through your rules, never around them. Ask the person first.',
+          'Taiga merges through your rules, never around them.',
         inputSchema: z.object({
           itemId: idInput('backlog item', 'taiga_list_backlog_items (query finds one by title) gives it'),
           autoMerge: z