@taiga-ai/mcp-server 0.18.0-dev.450 → 0.19.0-dev.451

package/src/server.integration.test.ts

@@ -4,6 +4,10 @@ import { serveStdio } from '@modelcontextprotocol/server/stdio';
 import { TaigaClient } from './client.js';
 import { createServer } from './server.js';
 import type { WaitOptions } from './tools/wait.js';
+import { inProductWords } from './tools/errors.js';
+
+/** What a tool returns for an API value: its keys in the product's words (PRO-2800). */
+const asSeen = <T>(value: T): T => inProductWords(value) as T;
 
 // ---------------------------------------------------------------------------
 // Helpers -- thin wrappers, not abstraction layers
@@ -42,15 +46,15 @@ const ALL_TOOL_NAMES = [
   'taiga_fix_finding',
   'taiga_fix_policy_violation',
   'taiga_generate_product_documents',
-  'taiga_get_backlog_item',
-  'taiga_get_build',
   'taiga_get_delivery_metrics',
   'taiga_get_deployments',
   'taiga_get_document',
   'taiga_get_factory_document',
   'taiga_get_finding',
+  'taiga_get_initiative',
   'taiga_get_job',
   'taiga_get_knowledge',
+  'taiga_get_line',
   'taiga_get_maintenance',
   'taiga_get_monitoring',
   'taiga_get_plan',
@@ -58,26 +62,26 @@ const ALL_TOOL_NAMES = [
   'taiga_get_product',
   'taiga_get_product_context',
   'taiga_get_product_document',
-  'taiga_get_queue',
+  'taiga_get_run',
   'taiga_ignore_finding',
   'taiga_link_repository',
   'taiga_list_action_required',
-  'taiga_list_backlog_items',
-  'taiga_list_builds',
   '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',
+  'taiga_list_runs',
   'taiga_list_setup_tasks',
   'taiga_mark_product_document_reviewed',
-  'taiga_move_backlog_item',
+  'taiga_move_initiative',
   'taiga_move_product',
   'taiga_pause_line',
   'taiga_plan_again',
@@ -85,7 +89,7 @@ const ALL_TOOL_NAMES = [
   'taiga_publish_document',
   'taiga_publish_factory_document',
   'taiga_publish_product_document',
-  'taiga_queue_backlog_item',
+  'taiga_queue_initiative',
   'taiga_refresh_reality_documents',
   'taiga_regenerate_product_document',
   'taiga_reject_plan',
@@ -94,24 +98,24 @@ const ALL_TOOL_NAMES = [
   'taiga_request_initiatives',
   'taiga_resolve_action',
   'taiga_resolve_product',
-  'taiga_resume_backlog_item',
+  'taiga_resume_initiative',
   'taiga_retry_knowledge',
   'taiga_set_auto_build',
   'taiga_set_auto_merge',
   'taiga_set_product_autonomy',
   'taiga_set_repository_branch',
   'taiga_start_import',
-  'taiga_stop_build',
   'taiga_stop_generating_documents',
+  'taiga_stop_run',
   'taiga_unlink_repository',
   'taiga_update_document',
   'taiga_update_environment',
   'taiga_update_factory_document',
   'taiga_update_product',
   'taiga_update_product_document',
-  'taiga_wait_for_backlog_item',
-  'taiga_wait_for_build',
+  'taiga_wait_for_initiative',
   'taiga_wait_for_job',
+  'taiga_wait_for_run',
 ];
 
 const PRODUCT_ID = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5c';
@@ -434,10 +438,10 @@ describe('MCP server integration', () => {
         'taiga_resolve_product',
         'taiga_list_product_documents',
         'taiga_get_product_document',
-        'taiga_list_builds',
-        'taiga_get_build',
-        'taiga_get_queue',
-        'taiga_wait_for_build',
+        'taiga_list_runs',
+        'taiga_get_run',
+        'taiga_get_line',
+        'taiga_wait_for_run',
         'taiga_get_job',
         'taiga_wait_for_job',
         'taiga_get_maintenance',
@@ -461,12 +465,7 @@ describe('MCP server integration', () => {
         'taiga_move_product',
       ],
       'vcs:manage': ['taiga_link_repository', 'taiga_set_repository_branch', 'taiga_unlink_repository'],
-      'backlog:read': [
-        'taiga_list_backlog_items',
-        'taiga_get_backlog_item',
-        'taiga_get_plan',
-        'taiga_wait_for_backlog_item',
-      ],
+      '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'],
       'customDocuments:read': ['taiga_list_knowledge', 'taiga_get_knowledge'],
@@ -474,10 +473,10 @@ describe('MCP server integration', () => {
     const PAIRED_CONTRACT: Record<string, string[]> = {
       'tenant:documents:read tenant:documents:write': ['taiga_update_document', 'taiga_publish_document'],
       'factories:read factories:documents:write': ['taiga_update_factory_document', 'taiga_publish_factory_document'],
-      'backlog:write': ['taiga_move_backlog_item', 'taiga_set_auto_merge'],
-      'backlog:write products:write': ['taiga_queue_backlog_item'],
+      'backlog:write': ['taiga_move_initiative', 'taiga_set_auto_merge'],
+      'backlog:write products:write': ['taiga_queue_initiative'],
       'products:write': [
-        'taiga_resume_backlog_item',
+        'taiga_resume_initiative',
         'taiga_set_auto_build',
         'taiga_request_initiatives',
         'taiga_set_product_autonomy',
@@ -495,7 +494,7 @@ describe('MCP server integration', () => {
       'backlog:read backlog:write products:write': ['taiga_plan_again'],
       'products:read products:write': [
         'taiga_start_import',
-        'taiga_stop_build',
+        'taiga_stop_run',
         'taiga_pause_line',
         'taiga_ignore_finding',
         'taiga_fix_finding',
@@ -1136,7 +1135,7 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_list_backlog_items',
+        name: 'taiga_list_initiatives',
         arguments: { productId: PRODUCT_ID, status: 'in_progress', category: 'feature', includeArchived: true },
       });
 
@@ -1156,7 +1155,7 @@ describe('MCP server integration', () => {
         routes: { [`/v1/backlog/${ITEM_ID}`]: { data: item } },
       });
 
-      const result = await client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } });
 
       expect(parseToolResult(result)).toEqual(item);
     });
@@ -1168,8 +1167,8 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_list_builds',
-        arguments: { productId: PRODUCT_ID, backlogItemId: ITEM_ID },
+        name: 'taiga_list_runs',
+        arguments: { productId: PRODUCT_ID, initiativeId: ITEM_ID },
       });
 
       const [row] = parseToolResult(result).data;
@@ -1195,10 +1194,18 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_get_build', arguments: { buildId: BUILD_ID, full: true } });
+      const result = await client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID, full: true } });
 
       expect(result.isError).toBeFalsy();
-      expect(parseToolResult(result)).toEqual({ ...run, steps: [step] });
+      const { backlogItemId: _item, ...rest } = run;
+      expect(parseToolResult(result)).toEqual({
+        ...rest,
+        initiativeId: ITEM_ID,
+        // Completed with no merge recorded: an older run that settled on an open pull request.
+        disposition: 'unmerged',
+        outcome: 'Settled without merging: its pull request was left unmerged.',
+        steps: [step],
+      });
     });
 
     it('should drop tenantId from every response at the client, so a run, its steps, an item and a list row never carry it', async () => {
@@ -1214,14 +1221,22 @@ describe('MCP server integration', () => {
       });
 
       const build = parseToolResult(
-        await client.callTool({ name: 'taiga_get_build', arguments: { buildId: BUILD_ID, full: true } })
+        await client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID, full: true } })
       );
-      expect(build).toEqual({ ...run, steps: [{ ...step, verification: { ok: true } }] });
+      const { backlogItemId: _item, ...rest } = run;
+      expect(build).toEqual({
+        ...rest,
+        initiativeId: ITEM_ID,
+        disposition: 'unmerged',
+        outcome: 'Settled without merging: its pull request was left unmerged.',
+        steps: [{ ...step, verification: { ok: true } }],
+      });
       expect(JSON.stringify(build)).not.toContain('tenantId');
 
       const got = parseToolResult(
-        await client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+        await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
       );
+      // No lifecycle on this item, so no situation.
       expect(got).toEqual(item);
     });
 
@@ -1230,8 +1245,8 @@ describe('MCP server integration', () => {
       const before = fetchSpy.mock.calls.length;
 
       for (const [name, args] of [
-        ['taiga_list_backlog_items', { productId: PRODUCT_ID, limit: 2.5 }],
-        ['taiga_list_builds', { productId: PRODUCT_ID, limit: 2.5 }],
+        ['taiga_list_initiatives', { productId: PRODUCT_ID, limit: 2.5 }],
+        ['taiga_list_runs', { productId: PRODUCT_ID, limit: 2.5 }],
         ['taiga_list_products', { limit: 2.5 }],
       ] as const) {
         const result = await client.callTool({ name, arguments: { ...args } });
@@ -1245,8 +1260,8 @@ describe('MCP server integration', () => {
 
       const names = toolNames((await client.listTools()).tools);
 
-      expect(names).toContain('taiga_list_builds');
-      expect(names).not.toContain('taiga_list_backlog_items');
+      expect(names).toContain('taiga_list_runs');
+      expect(names).not.toContain('taiga_list_initiatives');
     });
   });
 
@@ -1949,6 +1964,34 @@ describe('MCP server integration', () => {
       },
       [`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}/inbox`]: {
+        data: [
+          { id: 'i1', kind: 'review_pr', status: 'open' },
+          { id: 'i2', kind: 'review_pr', status: 'open' },
+          { id: 'i3', kind: 'setup_secret', status: 'snoozed', snoozedUntil: '2999-01-01T00:00:00.000Z' },
+        ],
+        nextCursor: null,
+        totalCount: 3,
+      },
+      [`GET /v1/products/${PRODUCT_ID}/maintenance/summary`]: {
+        data: {
+          openFindings: 1,
+          severityCounts: { critical: 0, high: 1 },
+          lastRun: { id: 'sweep-1', status: 'completed', completedAt: '2026-10-01T00:00:00.000Z', findingsCount: 1 },
+        },
+      },
+      [`GET /v1/products/${PRODUCT_ID}/maintenance/policies`]: {
+        // The API's own shape: the lists, no summary.
+        data: {
+          controls: [
+            { controlId: 'SEC-1', divergenceCount: 2, findingCount: 0 },
+            { controlId: 'SEC-2', divergenceCount: 0, findingCount: 1 },
+            { controlId: 'SEC-3', divergenceCount: 0, findingCount: 0 },
+          ],
+          divergences: [{ severity: 'critical' }, { severity: 'high' }, { severity: 'high' }],
+          resolvedDivergences: [],
+        },
+      },
     };
 
     it('should assemble every part in one call and name the one document that is not published', async () => {
@@ -2003,7 +2046,24 @@ describe('MCP server integration', () => {
         ],
         truncated: false,
       });
-      expect(bundle.builds).toEqual([{ id: BUILD_ID, runNumber: 1, status: 'completed', targetTitle: 'Add login' }]);
+      expect(bundle.builds).toEqual([
+        {
+          id: BUILD_ID,
+          runNumber: 1,
+          status: 'completed',
+          targetTitle: 'Add login',
+          disposition: 'unmerged',
+          outcome: 'Settled without a merged pull request.',
+        },
+      ]);
+      // PRO-2800: "how does it stand" in the same call, as counts.
+      expect(bundle.attention).toEqual({ open: 3, byKind: { review_pr: 2, setup_secret: 1 }, snoozed: 1 });
+      expect(bundle.maintenance).toEqual({
+        openFindings: 1,
+        bySeverity: { critical: 0, high: 1 },
+        lastSweep: { status: 'completed', completedAt: '2026-10-01T00:00:00.000Z' },
+      });
+      expect(bundle.standing).toEqual({ openViolations: 3, bySeverity: { critical: 1, high: 2 }, controlsViolated: 2 });
       expect(bundle.notGranted).toEqual([]);
       expect(bundle.unavailable).toEqual({});
     });
@@ -2328,8 +2388,8 @@ describe('MCP server integration', () => {
         `/v1/factories/${FACTORY_ID}/documents`,
         ['factories:read'],
       ],
-      ['taiga_list_backlog_items', { productId: PRODUCT_ID }, `/v1/products/${PRODUCT_ID}/backlog`, ['backlog:read']],
-      ['taiga_list_builds', { productId: PRODUCT_ID }, `/v1/products/${PRODUCT_ID}/builds`, ['products:read']],
+      ['taiga_list_initiatives', { productId: PRODUCT_ID }, `/v1/products/${PRODUCT_ID}/backlog`, ['backlog:read']],
+      ['taiga_list_runs', { productId: PRODUCT_ID }, `/v1/products/${PRODUCT_ID}/builds`, ['products:read']],
     ] as const)('%s passes the cursor on and returns where the next page starts', async (name, args, path, caps) => {
       const { client, fetchSpy } = await bootMcpPair({
         capabilities: [...caps],
@@ -2385,9 +2445,9 @@ describe('MCP server integration', () => {
         mimeType: 'text/markdown',
       });
       expect(resourceTemplates.map((t) => t.uriTemplate).sort()).toEqual([
-        'taiga://backlog/{itemId}',
         'taiga://documents/{type}',
         'taiga://factories/{factoryId}/instructions',
+        'taiga://initiatives/{initiativeId}',
         'taiga://products/{productId}/documents/{type}',
         'taiga://products/{productId}/documents/{type}{?origin}',
       ]);
@@ -2398,7 +2458,7 @@ describe('MCP server integration', () => {
 
       const { resourceTemplates } = await client.listResourceTemplates();
 
-      expect(resourceTemplates.map((t) => t.uriTemplate)).toEqual(['taiga://backlog/{itemId}']);
+      expect(resourceTemplates.map((t) => t.uriTemplate)).toEqual(['taiga://initiatives/{initiativeId}']);
     });
 
     it('should read a policy as Markdown with its sections as headings and no provenance', async () => {
@@ -2463,7 +2523,7 @@ describe('MCP server integration', () => {
       });
 
       const instructions = await client.readResource({ uri: `taiga://factories/${FACTORY_ID}/instructions` });
-      const backlog = await client.readResource({ uri: `taiga://backlog/${ITEM_ID}` });
+      const backlog = await client.readResource({ uri: `taiga://initiatives/${ITEM_ID}` });
 
       expect(textOf(instructions.contents)).toContain('## instructions\n\nUse pnpm.');
       expect(backlog.contents[0]!.mimeType).toBe('application/json');
@@ -2475,7 +2535,7 @@ describe('MCP server integration', () => {
       const before = fetchSpy.mock.calls.length;
 
       await expect(client.readResource({ uri: 'taiga://documents/policy_ip' })).rejects.toThrow(/not one of/);
-      await expect(client.readResource({ uri: 'taiga://backlog/not-an-id' })).rejects.toThrow(/not an ID/);
+      await expect(client.readResource({ uri: 'taiga://initiatives/not-an-id' })).rejects.toThrow(/not an ID/);
       await expect(client.readResource({ uri: 'taiga://nothing/here' })).rejects.toThrow(/not found/);
       await expect(
         client.readResource({ uri: `taiga://products/${PRODUCT_ID}/documents/architecture?origin=` })
@@ -2601,7 +2661,7 @@ describe('MCP server integration', () => {
       const docsOnly = await bootMcpPair({ capabilities: ['tenant:documents:read'] });
 
       expect((await full.client.listPrompts()).prompts.map((p) => p.name).sort()).toEqual([
-        'taiga_implement_backlog_item',
+        'taiga_implement_initiative',
         'taiga_review_against_policies',
         'taiga_start_session',
       ]);
@@ -2643,7 +2703,10 @@ describe('MCP server integration', () => {
         routes: { ...routes, [`GET /v1/products/${PRODUCT_ID}`]: { data: named } },
       });
 
-      const result = await client.getPrompt({ name: 'taiga_implement_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.getPrompt({
+        name: 'taiga_implement_initiative',
+        arguments: { initiativeId: ITEM_ID },
+      });
 
       const text = (result.messages[0]!.content as { text: string }).text;
       expect(text.split('## Initiative')[0]).not.toContain('(none apply)');
@@ -2720,25 +2783,28 @@ describe('MCP server integration', () => {
       const before = fetchSpy.mock.calls.length;
 
       const notAnId = await client
-        .getPrompt({ name: 'taiga_implement_backlog_item', arguments: { itemId: 'PRO-123' } })
+        .getPrompt({ name: 'taiga_implement_initiative', arguments: { initiativeId: 'PRO-123' } })
         .catch((e: unknown) => e);
       expect(notAnId).toMatchObject({ code: -32602 });
       expect(fetchSpy.mock.calls.length).toBe(before);
 
       const unseen = await client
         .getPrompt({
-          name: 'taiga_implement_backlog_item',
-          arguments: { itemId: '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a99' },
+          name: 'taiga_implement_initiative',
+          arguments: { initiativeId: '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a99' },
         })
         .catch((e: unknown) => e);
       expect(unseen).toMatchObject({ code: -32602 });
-      expect(String((unseen as Error).message)).toContain('taiga_list_backlog_items shows what exists');
+      expect(String((unseen as Error).message)).toContain('taiga_list_initiatives shows what exists');
     });
 
     it('should assemble an initiative with its criteria, the architecture, the instructions and the policy sections', async () => {
       const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES, routes });
 
-      const result = await client.getPrompt({ name: 'taiga_implement_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.getPrompt({
+        name: 'taiga_implement_initiative',
+        arguments: { initiativeId: ITEM_ID },
+      });
 
       const text = (result.messages[0]!.content as { text: string }).text;
       expect(text).toContain('Users can log in');
@@ -2750,7 +2816,10 @@ describe('MCP server integration', () => {
     it('should say which parts a narrower key could not read rather than drop them', async () => {
       const { client } = await bootMcpPair({ capabilities: ['products:read', 'backlog:read'], routes });
 
-      const result = await client.getPrompt({ name: 'taiga_implement_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.getPrompt({
+        name: 'taiga_implement_initiative',
+        arguments: { initiativeId: ITEM_ID },
+      });
 
       const text = (result.messages[0]!.content as { text: string }).text;
       expect(text).toContain('(The factory instructions need factories:read, which this key lacks.)');
@@ -2766,7 +2835,10 @@ describe('MCP server integration', () => {
         return { ok: false, status: 403, json: async () => body, text: async () => JSON.stringify(body) };
       });
 
-      const result = await client.getPrompt({ name: 'taiga_implement_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.getPrompt({
+        name: 'taiga_implement_initiative',
+        arguments: { initiativeId: ITEM_ID },
+      });
 
       const text = (result.messages[0]!.content as { text: string }).text;
       expect(text).toContain(
@@ -2878,12 +2950,12 @@ describe('MCP server integration', () => {
       const byName = Object.fromEntries(tools.map((t) => [t.name, t.annotations]));
 
       for (const name of [
-        'taiga_queue_backlog_item',
-        'taiga_move_backlog_item',
-        'taiga_resume_backlog_item',
+        'taiga_queue_initiative',
+        'taiga_move_initiative',
+        'taiga_resume_initiative',
         'taiga_approve_plan',
         'taiga_reject_plan',
-        'taiga_stop_build',
+        'taiga_stop_run',
         'taiga_request_initiatives',
         'taiga_plan_again',
         'taiga_define_environment',
@@ -3080,7 +3152,7 @@ describe('MCP server integration', () => {
         routes: { [`PUT /v1/backlog/${ITEM_ID}/state`]: { data: queued } },
       });
 
-      const result = await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.callTool({ name: 'taiga_queue_initiative', arguments: { initiativeId: ITEM_ID } });
 
       expect(result.isError).toBeFalsy();
       // One write to the item, no item read around it: the route answers with the item (the reads
@@ -3097,12 +3169,15 @@ describe('MCP server integration', () => {
         routes: { [`PUT /v1/backlog/${ITEM_ID}/state`]: { data: queued } },
       });
 
-      await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID, afterId: OTHER_ITEM } });
+      await client.callTool({
+        name: 'taiga_queue_initiative',
+        arguments: { initiativeId: ITEM_ID, afterId: OTHER_ITEM },
+      });
       expect(sentBody(fetchSpy, 'PUT', `/backlog/${ITEM_ID}/state`)).toEqual({ state: 'queue', afterId: OTHER_ITEM });
 
       fetchSpy.mockClear();
       vi.stubGlobal('fetch', fetchSpy);
-      await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID, afterId: null } });
+      await client.callTool({ name: 'taiga_queue_initiative', arguments: { initiativeId: ITEM_ID, afterId: null } });
       expect(sentBody(fetchSpy, 'PUT', `/backlog/${ITEM_ID}/state`)).toEqual({ state: 'queue', afterId: null });
     });
 
@@ -3114,7 +3189,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.callTool({ name: 'taiga_queue_initiative', arguments: { initiativeId: ITEM_ID } });
 
       expect(result.isError).toBe(true);
       expect(outcomeOf(result)).toEqual({ error: 'CONFLICT', message: 'Stop the running agent before re-planning' });
@@ -3123,7 +3198,7 @@ describe('MCP server integration', () => {
     it('should report an item the key cannot see as a miss', async () => {
       const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 
-      const result = await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.callTool({ name: 'taiga_queue_initiative', arguments: { initiativeId: ITEM_ID } });
 
       expect(result.isError).toBe(true);
       expect(outcomeOf(result).error).toBe('NOT_FOUND');
@@ -3134,7 +3209,7 @@ describe('MCP server integration', () => {
       const operatorOnly = await bootMcpPair({ capabilities: ['products:write'] });
 
       expect(toolNames((await backlogOnly.client.listTools()).tools)).toEqual([
-        'taiga_move_backlog_item',
+        'taiga_move_initiative',
         'taiga_set_auto_merge',
       ]);
       // A request, the resume and the review gate take a product or an item ID a request or a queue hands
@@ -3148,7 +3223,7 @@ describe('MCP server integration', () => {
         'taiga_refresh_reality_documents',
         'taiga_reopen_discovery',
         'taiga_request_initiatives',
-        'taiga_resume_backlog_item',
+        'taiga_resume_initiative',
         'taiga_set_auto_build',
         'taiga_set_product_autonomy',
         'taiga_stop_generating_documents',
@@ -3161,8 +3236,8 @@ describe('MCP server integration', () => {
       const before = narrow.fetchSpy.mock.calls.length;
 
       const result = await narrow.client.callTool({
-        name: 'taiga_move_backlog_item',
-        arguments: { itemId: ITEM_ID, state: 'queue' },
+        name: 'taiga_move_initiative',
+        arguments: { initiativeId: ITEM_ID, state: 'queue' },
       });
 
       expect(result.isError).toBe(true);
@@ -3182,7 +3257,10 @@ describe('MCP server integration', () => {
           [`PUT /v1/backlog/${ITEM_ID}/state`]: { data: { ...atStation, planningStatus: 'planning' } },
         },
       });
-      const replanned = await station.client.callTool({ name: 'taiga_plan_again', arguments: { itemId: ITEM_ID } });
+      const replanned = await station.client.callTool({
+        name: 'taiga_plan_again',
+        arguments: { initiativeId: ITEM_ID },
+      });
       expect(replanned.isError).toBeFalsy();
       expect(sentBody(station.fetchSpy, 'PUT', `/backlog/${ITEM_ID}/state`)).toEqual({ state: 'plan' });
       expect(outcomeOf(replanned)).toMatchObject({ state: 'plan', planningStatus: 'planning' });
@@ -3191,7 +3269,7 @@ describe('MCP server integration', () => {
         capabilities: ALL_CAPABILITIES,
         routes: { [`GET /v1/backlog/${ITEM_ID}`]: { data: item } },
       });
-      const refused = await idle.client.callTool({ name: 'taiga_plan_again', arguments: { itemId: ITEM_ID } });
+      const refused = await idle.client.callTool({ name: 'taiga_plan_again', arguments: { initiativeId: ITEM_ID } });
       expect(refused.isError).toBe(true);
       expect(outcomeOf(refused).message).toMatch(/not at the Build station\. The queue is the only way to start work/);
       // Refused on the read: no move was sent.
@@ -3208,7 +3286,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      await client.callTool({ name: 'taiga_plan_again', arguments: { itemId: ITEM_ID, force: true } });
+      await client.callTool({ name: 'taiga_plan_again', arguments: { initiativeId: ITEM_ID, force: true } });
 
       expect(sentBody(fetchSpy, 'PUT', `/backlog/${ITEM_ID}/state`)).toEqual({ state: 'plan', force: true });
     });
@@ -3235,8 +3313,8 @@ describe('MCP server integration', () => {
           'Initiatives are already being generated for this product',
         ],
         [
-          'taiga_resume_backlog_item',
-          { itemId: ITEM_ID },
+          'taiga_resume_initiative',
+          { initiativeId: ITEM_ID },
           'CONFLICT',
           'This initiative is not stopped, so there is nothing to resume.',
         ],
@@ -3256,8 +3334,8 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_move_backlog_item',
-        arguments: { itemId: ITEM_ID, state: 'todo', afterId: null },
+        name: 'taiga_move_initiative',
+        arguments: { initiativeId: ITEM_ID, state: 'todo', afterId: null },
       });
 
       expect(result.isError).toBeFalsy();
@@ -3276,8 +3354,8 @@ describe('MCP server integration', () => {
       });
 
       const filed = await client.callTool({
-        name: 'taiga_move_backlog_item',
-        arguments: { itemId: ITEM_ID, state: 'canceled', archived: true },
+        name: 'taiga_move_initiative',
+        arguments: { initiativeId: ITEM_ID, state: 'canceled', archived: true },
       });
 
       expect(filed.isError).toBeFalsy();
@@ -3287,8 +3365,8 @@ describe('MCP server integration', () => {
       fetchSpy.mockClear();
       vi.stubGlobal('fetch', fetchSpy);
       await client.callTool({
-        name: 'taiga_move_backlog_item',
-        arguments: { itemId: ITEM_ID, state: 'todo', archived: false },
+        name: 'taiga_move_initiative',
+        arguments: { initiativeId: ITEM_ID, state: 'todo', archived: false },
       });
       expect(sentBody(fetchSpy, 'PUT', `/backlog/${ITEM_ID}/state`)).toEqual({ state: 'todo', archived: false });
     });
@@ -3306,8 +3384,8 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_move_backlog_item',
-        arguments: { itemId: ITEM_ID, state: 'done', archived: true },
+        name: 'taiga_move_initiative',
+        arguments: { initiativeId: ITEM_ID, state: 'done', archived: true },
       });
 
       expect(result.isError).toBe(true);
@@ -3321,7 +3399,7 @@ describe('MCP server integration', () => {
       const { client, fetchSpy } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 
       const { tools } = await client.listTools();
-      const move = tools.find((t) => t.name === 'taiga_move_backlog_item')!;
+      const move = tools.find((t) => t.name === 'taiga_move_initiative')!;
       const props = move.inputSchema.properties as Record<string, { enum?: string[] }>;
       // The queue is the only way to start work: no "plan this now", nothing dropped into Build.
       expect(props['state']!.enum).toEqual(['backlog', 'todo', 'queue', 'done', 'canceled']);
@@ -3329,8 +3407,8 @@ describe('MCP server integration', () => {
       const before = fetchSpy.mock.calls.length;
       for (const state of ['build', 'plan']) {
         const result = await client.callTool({
-          name: 'taiga_move_backlog_item',
-          arguments: { itemId: ITEM_ID, state },
+          name: 'taiga_move_initiative',
+          arguments: { initiativeId: ITEM_ID, state },
         });
         expect(result.isError, state).toBe(true);
       }
@@ -3346,8 +3424,8 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_move_backlog_item',
-        arguments: { itemId: ITEM_ID, state: 'todo' },
+        name: 'taiga_move_initiative',
+        arguments: { initiativeId: ITEM_ID, state: 'todo' },
       });
 
       expect(result.isError).toBe(true);
@@ -3361,7 +3439,7 @@ describe('MCP server integration', () => {
         routes: { [`POST /v1/backlog/${ITEM_ID}/resume`]: { data: resumed } },
       });
 
-      const result = await client.callTool({ name: 'taiga_resume_backlog_item', arguments: { itemId: ITEM_ID } });
+      const result = await client.callTool({ name: 'taiga_resume_initiative', arguments: { initiativeId: ITEM_ID } });
 
       expect(result.isError).toBeFalsy();
       const call = fetchSpy.mock.calls.find((c: unknown[]) => (c[0] as string).endsWith('/resume'))!;
@@ -3379,11 +3457,11 @@ describe('MCP server integration', () => {
         },
       });
 
-      const found = await client.callTool({ name: 'taiga_get_plan', arguments: { itemId: ITEM_ID } });
+      const found = await client.callTool({ name: 'taiga_get_plan', arguments: { initiativeId: ITEM_ID } });
       // A summary by default: the step's prose, timestamps and planId stay behind.
       expect(outcomeOf(found)).toEqual({
         id: PLAN_ID,
-        backlogItemId: ITEM_ID,
+        initiativeId: ITEM_ID,
         version: 1,
         status: 'active',
         steps: [
@@ -3400,19 +3478,21 @@ describe('MCP server integration', () => {
         ],
       });
 
-      const full = await client.callTool({ name: 'taiga_get_plan', arguments: { itemId: ITEM_ID, full: true } });
+      const full = await client.callTool({ name: 'taiga_get_plan', arguments: { initiativeId: ITEM_ID, full: true } });
       const { tenantId: _t, ...planWithoutTenant } = plan;
-      expect(outcomeOf(full)).toEqual({
-        ...planWithoutTenant,
-        steps: plan.steps.map(({ tenantId: _s, ...step }) => step),
-      });
+      expect(outcomeOf(full)).toEqual(
+        asSeen({
+          ...planWithoutTenant,
+          steps: plan.steps.map(({ tenantId: _s, ...step }) => step),
+        })
+      );
 
-      const none = await client.callTool({ name: 'taiga_get_plan', arguments: { itemId: OTHER_ITEM } });
+      const none = await client.callTool({ name: 'taiga_get_plan', arguments: { initiativeId: OTHER_ITEM } });
       expect(none.isError).toBe(true);
       expect(outcomeOf(none)).toEqual({
         error: 'NOT_FOUND',
         message:
-          'No active plan found. taiga_get_backlog_item says whether one is being generated (planningStatus planning) or failed, and taiga_plan_again asks for a new one.',
+          'No active plan found. taiga_get_initiative says whether one is being generated (planningStatus planning) or failed, and taiga_plan_again asks for a new one.',
       });
     });
 
@@ -3473,18 +3553,20 @@ describe('MCP server integration', () => {
         },
       });
 
-      const stop = await client.callTool({ name: 'taiga_stop_build', arguments: { buildId: BUILD_ID } });
+      const stop = await client.callTool({ name: 'taiga_stop_run', arguments: { runId: BUILD_ID } });
       expect(stop.isError).toBeFalsy();
       expect(outcomeOf(stop)).toEqual({
         id: BUILD_ID,
         runNumber: 1,
-        backlogItemId: ITEM_ID,
+        initiativeId: ITEM_ID,
         status: 'stopped',
         failedReason: 'user_stopped',
         completedSteps: 1,
         totalSteps: 3,
         prUrl: null,
         actions: ['resume', 'start_over'],
+        disposition: 'stopped',
+        outcome: 'Stopped before it finished (1 of 3 steps done).',
       });
       const call = fetchSpy.mock.calls.find((c: unknown[]) => (c[0] as string).endsWith('/stop'))!;
       expect((call[1] as RequestInit).body).toBeNull();
@@ -3498,7 +3580,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_stop_build', arguments: { buildId: BUILD_ID } });
+      const result = await client.callTool({ name: 'taiga_stop_run', arguments: { runId: BUILD_ID } });
 
       expect(result.isError).toBe(true);
       expect(outcomeOf(result)).toEqual({ error: 'CONFLICT', message: 'Cannot stop a run that is completed' });
@@ -3520,7 +3602,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_builds', arguments: { active: true, limit: 10 } });
+      const result = await client.callTool({ name: 'taiga_list_runs', arguments: { active: true, limit: 10 } });
 
       expect(result.isError).toBeFalsy();
       const { data, nextCursor } = outcomeOf(result);
@@ -3541,11 +3623,11 @@ describe('MCP server integration', () => {
       expect(sentUrl(fetchSpy, '/products').searchParams.get('limit')).toBe('100');
     });
 
-    it('should refuse backlogItemId without productId before any request rather than answer with every run', async () => {
+    it('should refuse initiativeId without productId before any request rather than answer with every run', async () => {
       const { client, fetchSpy } = await bootMcpPair({ capabilities: ['products:read'] });
       const before = fetchSpy.mock.calls.length;
 
-      const result = await client.callTool({ name: 'taiga_list_builds', arguments: { backlogItemId: ITEM_ID } });
+      const result = await client.callTool({ name: 'taiga_list_runs', arguments: { initiativeId: ITEM_ID } });
 
       expect(result.isError).toBe(true);
       expect(outcomeOf(result)).toMatchObject({ error: 'VALIDATION_ERROR' });
@@ -3561,7 +3643,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_builds', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_list_runs', arguments: {} });
 
       const { data, note } = outcomeOf(result);
       expect(data[0]).not.toHaveProperty('product');
@@ -3577,7 +3659,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const { data, note } = outcomeOf(await client.callTool({ name: 'taiga_list_builds', arguments: {} }));
+      const { data, note } = outcomeOf(await client.callTool({ name: 'taiga_list_runs', arguments: {} }));
 
       expect(data[0]).not.toHaveProperty('product');
       expect(note).toMatch(/cannot list \(deleted since, or not visible/);
@@ -3593,7 +3675,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = outcomeOf(await client.callTool({ name: 'taiga_list_builds', arguments: {} }));
+      const result = outcomeOf(await client.callTool({ name: 'taiga_list_runs', arguments: {} }));
 
       expect(result.data[0].product).toEqual({ name: 'Web', slug: 'web' });
       expect(result).not.toHaveProperty('note');
@@ -3609,7 +3691,7 @@ describe('MCP server integration', () => {
           },
         },
       });
-      const result = outcomeOf(await offline.client.callTool({ name: 'taiga_list_builds', arguments: {} }));
+      const result = outcomeOf(await offline.client.callTool({ name: 'taiga_list_runs', arguments: {} }));
       expect(result.data[0]).not.toHaveProperty('product');
       expect(result.note).toMatch(/products could not be read/);
 
@@ -3622,7 +3704,7 @@ describe('MCP server integration', () => {
           },
         },
       });
-      const failure = await buggy.client.callTool({ name: 'taiga_list_builds', arguments: {} });
+      const failure = await buggy.client.callTool({ name: 'taiga_list_runs', arguments: {} });
       expect(failure.isError).toBe(true);
       expect(JSON.stringify(failure.content)).toContain('a bug in the products path');
       expect(JSON.stringify(failure.content)).not.toContain('could not be read');
@@ -3637,7 +3719,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_builds', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_list_runs', arguments: {} });
 
       expect(result.isError).toBeFalsy();
       const { data, note } = outcomeOf(result);
@@ -3656,7 +3738,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      expect(outcomeOf(await client.callTool({ name: 'taiga_list_builds', arguments: {} }))).not.toHaveProperty('note');
+      expect(outcomeOf(await client.callTool({ name: 'taiga_list_runs', arguments: {} }))).not.toHaveProperty('note');
     });
 
     it('should refuse active with productId before any request rather than drop the filter', async () => {
@@ -3664,7 +3746,7 @@ describe('MCP server integration', () => {
       const before = fetchSpy.mock.calls.length;
 
       const result = await client.callTool({
-        name: 'taiga_list_builds',
+        name: 'taiga_list_runs',
         arguments: { productId: PRODUCT_ID, active: true },
       });
 
@@ -3679,7 +3761,7 @@ describe('MCP server integration', () => {
         routes: { [`/v1/products/${PRODUCT_ID}/builds`]: { data: [run], nextCursor: null } },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_builds', arguments: { productId: PRODUCT_ID } });
+      const result = await client.callTool({ name: 'taiga_list_runs', arguments: { productId: PRODUCT_ID } });
 
       expect(result.isError).toBeFalsy();
       expect(fetchSpy.mock.calls.some((c: unknown[]) => (c[0] as string).endsWith('/v1/products?limit=100'))).toBe(
@@ -3758,7 +3840,7 @@ describe('MCP server integration', () => {
       });
 
       const rows = parseToolResult(
-        await client.callTool({ name: 'taiga_list_backlog_items', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: PRODUCT_ID } })
       ).data;
 
       expect(rows[0].criteria).toEqual({ met: 1, total: 2 });
@@ -3791,9 +3873,7 @@ describe('MCP server integration', () => {
         routes: { [`/v1/builds/${BUILD_ID}`]: { data: run }, [`/v1/builds/${BUILD_ID}/steps`]: { data: steps } },
       });
 
-      const result = parseToolResult(
-        await client.callTool({ name: 'taiga_get_build', arguments: { buildId: BUILD_ID } })
-      );
+      const result = parseToolResult(await client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } }));
 
       expect(result).toMatchObject(run);
       expect(result.steps[0]).toEqual({
@@ -3828,7 +3908,7 @@ describe('MCP server integration', () => {
       });
 
       const queue = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(queue.entries.map((row: { title: string }) => row.title)).toEqual(['ARC-3.3 OpenAPI', 'README']);
@@ -3860,10 +3940,10 @@ describe('MCP server integration', () => {
       });
 
       const queue = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
 
-      expect(queue.entries[0]).toMatchObject({ buildId: BUILD_ID, prUrl: 'https://github.com/acme/web/pull/22' });
+      expect(queue.entries[0]).toMatchObject({ runId: BUILD_ID, prUrl: 'https://github.com/acme/web/pull/22' });
       expect(queue.waitingOn).toBe(
         '"ARC-3.3 OpenAPI" is waiting on a person (review_pr) (https://github.com/acme/web/pull/22); every other queued initiative waits until its pull request merges.'
       );
@@ -3887,12 +3967,12 @@ describe('MCP server integration', () => {
       });
 
       const queue = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
       expect(queue.waitingOn).toMatch(/^"ARC-3.3 OpenAPI" is waiting on a person/);
 
       fetchSpy.mockClear();
-      const queued = await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID } });
+      const queued = await client.callTool({ name: 'taiga_queue_initiative', arguments: { initiativeId: ITEM_ID } });
       expect(queued.isError).toBeFalsy();
       // Placing an item names only the entry the line waits on: the active one.
       const itemReads = fetchSpy.mock.calls
@@ -3915,7 +3995,7 @@ describe('MCP server integration', () => {
       });
 
       const queue = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(queue.waitingOn).toContain('holding the entries behind it');
@@ -3937,7 +4017,7 @@ describe('MCP server integration', () => {
       });
 
       const queue = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(queue.waitingOn).toBe(
@@ -3964,7 +4044,7 @@ describe('MCP server integration', () => {
       expect(pause).toEqual({ productId: PRODUCT_ID, linePaused: true, lineStoppedAt: '2026-10-08T20:00:00.000Z' });
 
       const queue = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
       expect(queue.linePaused).toBe(true);
 
@@ -3989,7 +4069,7 @@ describe('MCP server integration', () => {
       // One pair at a time: each boot stubs the global fetch the previous client reads through.
       const noBacklog = await bootMcpPair({ capabilities: ['products:read'], routes: queueRoute });
       const without = parseToolResult(
-        await noBacklog.client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await noBacklog.client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
       expect(noBacklog.fetchSpy.mock.calls.some((c: unknown[]) => (c[0] as string).includes('/backlog/'))).toBe(false);
       const failing = await bootMcpPair({
@@ -3997,10 +4077,10 @@ describe('MCP server integration', () => {
         routes: { ...queueRoute, [`/v1/backlog/${HEAD_ITEM}`]: refusal(500, 'INTERNAL', 'boom') },
       });
       const failed = parseToolResult(
-        await failing.client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await failing.client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       );
 
-      expect(without.entries[0]).toEqual({ position: 1, backlogItemId: HEAD_ITEM, entryState: 'active' });
+      expect(without.entries[0]).toEqual({ position: 1, initiativeId: HEAD_ITEM, entryState: 'active' });
       expect(without.note).toContain('backlog:read');
       expect(failed.entries[0]).not.toHaveProperty('title');
       expect(failed.note).toContain('could not be read');
@@ -4020,7 +4100,10 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID, autoBuild: false } })
+        await client.callTool({
+          name: 'taiga_queue_initiative',
+          arguments: { initiativeId: ITEM_ID, autoBuild: false },
+        })
       );
 
       // To place one item and say what the line waits on, only the blocking entry is read.
@@ -4056,14 +4139,14 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_queue_backlog_item', arguments: { itemId: ITEM_ID } })
+        await client.callTool({ name: 'taiga_queue_initiative', arguments: { initiativeId: ITEM_ID } })
       );
 
       expect(fetchSpy.mock.calls.some((c: unknown[]) => (c[0] as string).includes('/auto-build'))).toBe(false);
       expect(result.reviewGate).toMatchObject({ buildsWithoutReview: true, decidedBy: 'product' });
       // The queue read missed (no route); the outcome says so rather than failing the write it reports.
       expect(result.queue).toBeNull();
-      expect(result.note).toContain('taiga_get_queue');
+      expect(result.note).toContain('taiga_get_line');
     });
 
     it('should set an initiative back to the product default with null and report the gate that now applies', async () => {
@@ -4076,7 +4159,7 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_set_auto_build', arguments: { itemId: ITEM_ID, autoBuild: null } })
+        await client.callTool({ name: 'taiga_set_auto_build', arguments: { initiativeId: ITEM_ID, autoBuild: null } })
       );
 
       expect(sentBody(fetchSpy, 'PUT', '/auto-build')).toEqual({ autoBuild: null });
@@ -4098,8 +4181,8 @@ describe('MCP server integration', () => {
 
       const result = parseToolResult(
         await client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'planned', timeoutSeconds: 30 },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'planned', timeoutSeconds: 30 },
         })
       );
 
@@ -4123,7 +4206,10 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_wait_for_backlog_item', arguments: { itemId: ITEM_ID, until: 'pr_open' } })
+        await client.callTool({
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'pr_open' },
+        })
       );
 
       expect(result).toMatchObject({ reached: false, stoppedBecause: 'needs a person: planning_failed' });
@@ -4143,8 +4229,8 @@ describe('MCP server integration', () => {
       });
       const plan = parseToolResult(
         await verdict.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'pr_open' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'pr_open' },
         })
       );
       expect(plan).toMatchObject({ reached: false, stoppedBecause: 'waits on a person: start_build' });
@@ -4156,8 +4242,8 @@ describe('MCP server integration', () => {
       });
       const unsure = parseToolResult(
         await unknown.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'your_turn' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'your_turn' },
         })
       );
       expect(unsure.reached).toBe(false);
@@ -4169,8 +4255,8 @@ describe('MCP server integration', () => {
       });
       const pr = parseToolResult(
         await review.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'done' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'done' },
         })
       );
       expect(pr).toMatchObject({ reached: false, stoppedBecause: 'waits on a person: review_pr' });
@@ -4196,8 +4282,8 @@ describe('MCP server integration', () => {
       const started = Date.now();
       const result = parseToolResult(
         await client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'planned', timeoutSeconds: 1 },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'planned', timeoutSeconds: 1 },
         })
       );
 
@@ -4218,8 +4304,8 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_wait_for_backlog_item',
-        arguments: { itemId: ITEM_ID, until: 'planned', timeoutSeconds: 1 },
+        name: 'taiga_wait_for_initiative',
+        arguments: { initiativeId: ITEM_ID, until: 'planned', timeoutSeconds: 1 },
       });
 
       expect(result.isError).toBeFalsy();
@@ -4244,7 +4330,10 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_wait_for_backlog_item', arguments: { itemId: ITEM_ID, until: 'changed' } })
+        await client.callTool({
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'changed' },
+        })
       );
 
       expect(result).toMatchObject({ reached: true, item: { latestBuild: { prState: 'closed' } } });
@@ -4268,7 +4357,10 @@ describe('MCP server integration', () => {
       const controller = new AbortController();
 
       const pending = client.callTool(
-        { name: 'taiga_wait_for_backlog_item', arguments: { itemId: ITEM_ID, until: 'planned', timeoutSeconds: 60 } },
+        {
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'planned', timeoutSeconds: 60 },
+        },
         { signal: controller.signal }
       );
       await vi.waitFor(() => expect(hung).toBeDefined());
@@ -4301,8 +4393,8 @@ describe('MCP server integration', () => {
       });
       const pr = parseToolResult(
         await shipped.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'pr_open' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'pr_open' },
         })
       );
       expect(pr).toMatchObject({ reached: false, stoppedBecause: 'the initiative is done' });
@@ -4318,8 +4410,8 @@ describe('MCP server integration', () => {
       });
       const done = parseToolResult(
         await dropped.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'done' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'done' },
         })
       );
       expect(done).toMatchObject({ reached: false, stoppedBecause: 'the initiative is canceled' });
@@ -4338,8 +4430,8 @@ describe('MCP server integration', () => {
       });
       const runPr = parseToolResult(
         await finished.client.callTool({
-          name: 'taiga_wait_for_build',
-          arguments: { buildId: BUILD_ID, until: 'pr_open' },
+          name: 'taiga_wait_for_run',
+          arguments: { runId: BUILD_ID, until: 'pr_open' },
         })
       );
       expect(runPr).toMatchObject({ reached: false, stoppedBecause: 'the run is completed' });
@@ -4374,7 +4466,10 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_wait_for_backlog_item', arguments: { itemId: ITEM_ID, until: 'pr_open' } })
+        await client.callTool({
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'pr_open' },
+        })
       );
 
       // Not stopped at the landed plan: the open gate builds it without anyone.
@@ -4402,8 +4497,8 @@ describe('MCP server integration', () => {
 
       const result = parseToolResult(
         await client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'your_turn' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'your_turn' },
         })
       );
 
@@ -4436,8 +4531,8 @@ describe('MCP server integration', () => {
 
       const result = parseToolResult(
         await client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'your_turn' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'your_turn' },
         })
       );
 
@@ -4460,7 +4555,10 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_wait_for_backlog_item', arguments: { itemId: ITEM_ID, until: 'changed' } })
+        await client.callTool({
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'changed' },
+        })
       );
 
       expect(result).toMatchObject({ reached: true, item: { autoBuild: false } });
@@ -4474,8 +4572,8 @@ describe('MCP server integration', () => {
 
       const result = parseToolResult(
         await client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'changed', timeoutSeconds: 1 },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'changed', timeoutSeconds: 1 },
         })
       );
 
@@ -4492,7 +4590,7 @@ describe('MCP server integration', () => {
       const onprogress = vi.fn();
 
       const result = await client.callTool(
-        { name: 'taiga_wait_for_backlog_item', arguments: { itemId: ITEM_ID, until: 'changed' } },
+        { name: 'taiga_wait_for_initiative', arguments: { initiativeId: ITEM_ID, until: 'changed' } },
         { onprogress }
       );
 
@@ -4509,8 +4607,8 @@ describe('MCP server integration', () => {
       });
       const step = parseToolResult(
         await stepped.client.callTool({
-          name: 'taiga_wait_for_build',
-          arguments: { buildId: BUILD_ID, until: 'step_done' },
+          name: 'taiga_wait_for_run',
+          arguments: { runId: BUILD_ID, until: 'step_done' },
         })
       );
       const failed = await bootMcpPair({
@@ -4519,8 +4617,8 @@ describe('MCP server integration', () => {
       });
       const settled = parseToolResult(
         await failed.client.callTool({
-          name: 'taiga_wait_for_build',
-          arguments: { buildId: BUILD_ID, until: 'pr_open' },
+          name: 'taiga_wait_for_run',
+          arguments: { runId: BUILD_ID, until: 'pr_open' },
         })
       );
 
@@ -4539,8 +4637,8 @@ describe('MCP server integration', () => {
       });
       const result = parseToolResult(
         await recovered.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'planned' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'planned' },
         })
       );
       expect(result.reached).toBe(true);
@@ -4551,8 +4649,8 @@ describe('MCP server integration', () => {
         routes: { [`/v1/backlog/${ITEM_ID}`]: () => (calls++ === 0 ? answer({ data: item }) : failing) },
       });
       const failed = await broken.client.callTool({
-        name: 'taiga_wait_for_backlog_item',
-        arguments: { itemId: ITEM_ID, until: 'planned' },
+        name: 'taiga_wait_for_initiative',
+        arguments: { initiativeId: ITEM_ID, until: 'planned' },
       });
       expect(failed.isError).toBe(true);
       expect(calls).toBe(4);
@@ -4566,8 +4664,8 @@ describe('MCP server integration', () => {
       });
       const stopped = parseToolResult(
         await planning.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'planned' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'planned' },
         })
       );
       expect(stopped).toMatchObject({ reached: false, stoppedBecause: 'planning failed' });
@@ -4579,8 +4677,8 @@ describe('MCP server integration', () => {
       });
       const changed = parseToolResult(
         await waiting.client.callTool({
-          name: 'taiga_wait_for_backlog_item',
-          arguments: { itemId: ITEM_ID, until: 'changed' },
+          name: 'taiga_wait_for_initiative',
+          arguments: { initiativeId: ITEM_ID, until: 'changed' },
         })
       );
       expect(changed).toMatchObject({ reached: true, item: { state: 'plan', needsHumanCause: null } });
@@ -4596,8 +4694,8 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_queue_backlog_item',
-        arguments: { itemId: ITEM_ID, autoBuild: false },
+        name: 'taiga_queue_initiative',
+        arguments: { initiativeId: ITEM_ID, autoBuild: false },
       });
 
       expect(result.isError).toBe(true);
@@ -4615,7 +4713,7 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_set_auto_build', arguments: { itemId: ITEM_ID, autoBuild: null } })
+        await client.callTool({ name: 'taiga_set_auto_build', arguments: { initiativeId: ITEM_ID, autoBuild: null } })
       );
 
       expect(result.reviewGate).toBeNull();
@@ -4629,7 +4727,7 @@ describe('MCP server integration', () => {
       });
 
       const result = parseToolResult(
-        await client.callTool({ name: 'taiga_set_auto_build', arguments: { itemId: ITEM_ID, autoBuild: false } })
+        await client.callTool({ name: 'taiga_set_auto_build', arguments: { initiativeId: ITEM_ID, autoBuild: false } })
       );
 
       expect(result.reviewGate).toMatchObject({ buildsWithoutReview: false, decidedBy: 'initiative' });
@@ -4654,17 +4752,17 @@ describe('MCP server integration', () => {
       });
 
       const [failed, refused, unknown] = parseToolResult(
-        await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } })
       ).entries;
 
       expect(failed.halt.nextStep).toMatch(/^It clears when the run is retried/);
       expect(refused.halt).toMatchObject({
         reason: 'No seats',
-        nextStep: expect.stringMatching(/^taiga_resume_backlog_item lifts it/),
+        nextStep: expect.stringMatching(/^taiga_resume_initiative lifts it/),
       });
       expect(unknown.halt).toMatchObject({
         reason: 'Stored prose',
-        nextStep: expect.stringContaining('taiga_get_backlog_item'),
+        nextStep: expect.stringContaining('taiga_get_initiative'),
       });
     });
 
@@ -4679,7 +4777,7 @@ describe('MCP server integration', () => {
         },
       });
 
-      const result = await client.callTool({ name: 'taiga_get_queue', arguments: { productId: PRODUCT_ID } });
+      const result = await client.callTool({ name: 'taiga_get_line', arguments: { productId: PRODUCT_ID } });
 
       expect(result.isError).toBe(true);
       expect((result.content as { text: string }[])[0]!.text).toContain('a bug, not the API');
@@ -4816,14 +4914,10 @@ describe('MCP server integration', () => {
       // 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({});
+      // No text matched, so no empty data.sections beside the ids (PRO-2800).
+      expect(missed).not.toHaveProperty('data');
       expect(missed.unknownSections).toEqual(['nope']);
-      expect(missed.omittedSections.map((s: { id: string }) => s.id)).toEqual([
-        'overview',
-        'features',
-        'flows',
-        'risks',
-      ]);
+      expect(missed.outline.map((s: { id: string }) => s.id)).toEqual(['overview', 'features', 'flows', 'risks']);
     });
 
     it('should read a product document as its outline with sections: []', async () => {
@@ -4836,8 +4930,8 @@ describe('MCP server integration', () => {
         })
       );
 
-      expect(outline.data.sections).toEqual({});
-      expect(outline.omittedSections).toEqual([
+      expect(outline).not.toHaveProperty('data');
+      expect(outline.outline).toEqual([
         { id: 'overview', characters: 5_000 },
         { id: 'features', characters: expect.any(Number) },
         { id: 'flows', characters: 5_000 },
@@ -5000,7 +5094,7 @@ describe('MCP server integration', () => {
           arguments: { productId: PRODUCT_ID, findingId: FINDING_ID },
         })
       );
-      expect(one).toMatchObject({ backlogItemId: ITEM_ID, finding: { id: FINDING_ID, status: 'remediating' } });
+      expect(one).toMatchObject({ initiativeId: ITEM_ID, finding: { id: FINDING_ID, status: 'remediating' } });
       expect(one.finding).not.toHaveProperty('fingerprint');
 
       const group = parseToolResult(
@@ -5016,7 +5110,7 @@ describe('MCP server integration', () => {
         currentVersion: '4.17.20',
         productRepositoryId: repoId,
       });
-      expect(group).toEqual({ backlogItemId: ITEM_ID, findingIds: [FINDING_ID] });
+      expect(group).toEqual({ initiativeId: ITEM_ID, findingIds: [FINDING_ID] });
 
       // A finding of another product is not fixed as a group of this one.
       const before = callsTo(fetchSpy, 'POST').length;
@@ -5122,7 +5216,7 @@ describe('MCP server integration', () => {
         arguments: { productId: PRODUCT_ID, controlId: 'SEC-3.4', violationId: VIOLATION_ID },
       });
 
-      expect(control).toEqual({ backlogItemId: ITEM_ID, divergenceIds: [VIOLATION_ID], created: true });
+      expect(control).toEqual({ initiativeId: ITEM_ID, divergenceIds: [VIOLATION_ID], created: true });
       expect(callsTo(fetchSpy, 'POST').map((u) => u.pathname)).toEqual([
         `/v1/products/${PRODUCT_ID}/maintenance/policies/controls/SEC-3.4/remediate`,
         `/v1/products/${PRODUCT_ID}/maintenance/policies/divergences/${VIOLATION_ID}/remediate`,
@@ -5180,17 +5274,17 @@ describe('MCP server integration', () => {
       expect(product.searchParams.has('resolved')).toBe(false);
 
       const done = parseToolResult(
-        await client.callTool({ name: 'taiga_resolve_action', arguments: { itemId: INBOX_ID, status: 'done' } })
+        await client.callTool({ name: 'taiga_resolve_action', arguments: { actionId: INBOX_ID, status: 'done' } })
       );
       expect(done.status).toBe('done');
       expect(sentBody(fetchSpy, 'PATCH', '/inbox/')).toEqual({ status: 'done' });
 
       fetchSpy.mockClear();
       vi.stubGlobal('fetch', fetchSpy);
-      await client.callTool({ name: 'taiga_resolve_action', arguments: { itemId: INBOX_ID, snoozedUntil: null } });
+      await client.callTool({ name: 'taiga_resolve_action', arguments: { actionId: INBOX_ID, snoozedUntil: null } });
       expect(sentBody(fetchSpy, 'PATCH', '/inbox/')).toEqual({ snoozedUntil: null });
 
-      const nothing = await client.callTool({ name: 'taiga_resolve_action', arguments: { itemId: INBOX_ID } });
+      const nothing = await client.callTool({ name: 'taiga_resolve_action', arguments: { actionId: INBOX_ID } });
       expect(nothing.isError).toBe(true);
     });
 
@@ -5511,7 +5605,7 @@ describe('MCP server integration', () => {
       expect(product).not.toHaveProperty('settings');
 
       const item = parseToolResult(
-        await client.callTool({ name: 'taiga_set_auto_merge', arguments: { itemId: ITEM_ID, autoMerge: false } })
+        await client.callTool({ name: 'taiga_set_auto_merge', arguments: { initiativeId: ITEM_ID, autoMerge: false } })
       );
       expect(sentBody(fetchSpy, 'PATCH', `/backlog/${ITEM_ID}`)).toEqual({ autoMerge: false });
       expect(item).not.toHaveProperty('description');
@@ -6332,11 +6426,11 @@ describe('what the agent review found (PRO-2759)', () => {
       },
     });
 
-    const item = await client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } });
+    const item = await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } });
     expect(parseToolResult(item)).toEqual({
       error: 'NOT_FOUND',
       message:
-        "Backlog item not found. taiga_list_backlog_items lists a product's initiatives with their IDs; a run or " +
+        "Backlog item not found. taiga_list_initiatives lists a product's initiatives with their IDs; a run or " +
         'plan ID is not one.',
     });
 
@@ -6344,10 +6438,34 @@ describe('what the agent review found (PRO-2759)', () => {
       name: 'taiga_list_repository_branches',
       arguments: { productId: PRODUCT_ID, repositoryId: LINK_ID },
     });
+    // The API names the link, so only the link is hinted: the product the call
+    // also named was right, and its hint read as blaming it (PRO-2800).
     expect(parseToolResult(branches).message).toBe(
       "Repository link not found. taiga_list_product_repositories lists the product's repository links; a GitHub " +
-        'repository id is not a link ID. taiga_list_products lists the products the key can see; a name is not ' +
-        'an ID (taiga_get_product takes a slug).'
+        'repository id is not a link ID.'
+    );
+  });
+
+  it('hints every ID the call named when the 404 does not say which one is missing (PRO-2800)', async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/products/${PRODUCT_ID}/repositories/${LINK_ID}/branches`]: refusal(
+          404,
+          'NOT_FOUND',
+          'The requested resource does not exist'
+        ),
+      },
+    });
+
+    const branches = await client.callTool({
+      name: 'taiga_list_repository_branches',
+      arguments: { productId: PRODUCT_ID, repositoryId: LINK_ID },
+    });
+    expect(parseToolResult(branches).message).toBe(
+      "The requested resource does not exist. taiga_list_product_repositories lists the product's repository " +
+        'links; a GitHub repository id is not a link ID. taiga_list_products lists the products the key can see; ' +
+        'a name is not an ID (taiga_get_product takes a slug).'
     );
   });
 
@@ -6361,12 +6479,16 @@ describe('what the agent review found (PRO-2759)', () => {
       },
     });
 
-    const noPlan = parseToolResult(await client.callTool({ name: 'taiga_get_plan', arguments: { itemId: ITEM_ID } }));
-    const noItem = parseToolResult(await client.callTool({ name: 'taiga_get_plan', arguments: { itemId: OTHER } }));
+    const noPlan = parseToolResult(
+      await client.callTool({ name: 'taiga_get_plan', arguments: { initiativeId: ITEM_ID } })
+    );
+    const noItem = parseToolResult(
+      await client.callTool({ name: 'taiga_get_plan', arguments: { initiativeId: OTHER } })
+    );
 
     expect(noPlan.message).toContain('taiga_plan_again asks for a new one');
     expect(noItem.message).toBe(
-      "Backlog item not found. taiga_list_backlog_items lists a product's initiatives with their IDs; a run or " +
+      "Backlog item not found. taiga_list_initiatives lists a product's initiatives with their IDs; a run or " +
         'plan ID is not one.'
     );
   });
@@ -6380,9 +6502,7 @@ describe('what the agent review found (PRO-2759)', () => {
       },
     });
 
-    const result = parseToolResult(
-      await client.callTool({ name: 'taiga_get_build', arguments: { buildId: BUILD_ID } })
-    );
+    const result = parseToolResult(await client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } }));
 
     expect(result.stoppedIn).toMatch(/^before the first step started/);
   });
@@ -6390,7 +6510,7 @@ describe('what the agent review found (PRO-2759)', () => {
   it('says where a product ID comes from when a name is passed for one', async () => {
     const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 
-    const result = await client.callTool({ name: 'taiga_list_backlog_items', arguments: { productId: 'Web shop' } });
+    const result = await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: 'Web shop' } });
 
     expect(result.isError).toBe(true);
     expect((result.content as { text: string }[])[0]!.text).toContain(
@@ -6456,12 +6576,12 @@ describe('what the agent review found (PRO-2759)', () => {
     // 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).not.toHaveProperty('data');
     expect(missed.unknownSections).toEqual(['secrets']);
-    expect(missed.omittedSections.map((s: { id: string }) => s.id)).toEqual(['summary', 'scope']);
+    expect(missed.outline.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 () => {
+  it('says what a product in setup still needs, from what is linked and what the API would refuse on (PRO-2800)', async () => {
     const draft = {
       id: PRODUCT_ID,
       name: 'Web',
@@ -6473,29 +6593,46 @@ describe('what the agent review found (PRO-2759)', () => {
       ownsInfrastructure: false,
       deploymentNotes: null,
     };
+    const blockers = { data: { inSetup: true, missingDocuments: ['specification', 'architecture'], openChecks: [] } };
+    let links: unknown[] = [];
     const { client } = await bootMcpPair({
       capabilities: ALL_CAPABILITIES,
       routes: {
         [`GET /v1/products/${PRODUCT_ID}`]: { data: draft },
         [`PATCH /v1/products/${PRODUCT_ID}`]: { data: draft },
+        [`GET /v1/products/${PRODUCT_ID}/setup`]: blockers,
+        [`GET /v1/products/${PRODUCT_ID}/repositories`]: () => ({
+          ok: true,
+          status: 200,
+          json: async () => ({ data: links, nextCursor: null }),
+          text: async () => JSON.stringify({ data: links, nextCursor: null }),
+        }),
       },
     });
 
     const product = parseToolResult(
       await client.callTool({ name: 'taiga_get_product', arguments: { productId: PRODUCT_ID } })
     );
-    expect(product.nextStep).toBe(
-      'Link its repository if it has none (taiga_list_linkable_repositories, taiga_link_repository), then ' +
-        'taiga_start_import: the import derives the documents from the code and runs by itself.'
-    );
-
+    expect(product.readiness).toEqual({
+      ready: false,
+      repository: { linked: false },
+      import: 'not started',
+      missingDocuments: ['Specification', 'Architecture'],
+      openChecks: [],
+      nextStep:
+        'Link its repository (taiga_list_linkable_repositories, then taiga_link_repository), then taiga_start_import.',
+    });
+
+    // Linked: the next move follows, which the step alone never said.
+    links = [{ id: LINK_ID, repositoryName: 'acme/web', effectiveBranch: 'main' }];
     const updated = parseToolResult(
       await client.callTool({
         name: 'taiga_update_product',
         arguments: { productId: PRODUCT_ID, ownsInfrastructure: false },
       })
     );
-    expect(updated.nextStep).toBe(product.nextStep);
+    expect(updated.readiness.repository).toEqual({ linked: true, name: 'acme/web', branch: 'main' });
+    expect(updated.readiness.nextStep).toMatch(/^taiga_start_import derives the documents from the code/);
     expect(updated.warnings).toEqual([expect.stringContaining('has no deploymentNotes')]);
   });
 
@@ -6510,16 +6647,56 @@ describe('what the agent review found (PRO-2759)', () => {
       },
     });
 
+    // An API without the setup read (404 here): the step is what there is to go on.
     const read = parseToolResult(
       await client.callTool({ name: 'taiga_update_product', arguments: { productId: PRODUCT_ID, name: 'Web' } })
     );
-    // The product's read is unreachable here (the mock answers 404): no nextStep, not the conversation's.
+    // The product's read is unreachable too: no next step, not the conversation's.
     const unread = parseToolResult(
       await client.callTool({ name: 'taiga_update_product', arguments: { productId: PRODUCT_ID_2, name: 'Web' } })
     );
 
-    expect(read.nextStep).toMatch(/^The specification is done/);
-    expect(unread).not.toHaveProperty('nextStep');
+    expect(read.readiness.ready).toBeNull();
+    expect(read.readiness.nextStep).toMatch(/^The specification is done/);
+    expect(unread.readiness.nextStep).toBeNull();
+    expect(unread.readiness.repository).toBeNull();
+  });
+
+  it('says what a scratch product still needs, from the Discovery conversation to the last document (PRO-2800)', async () => {
+    const draft = {
+      id: PRODUCT_ID,
+      name: 'Web',
+      slug: 'web',
+      status: 'draft',
+      factoryId: FACTORY_ID,
+      discoveryStep: 'documents',
+      settings: {},
+    };
+    let missing = ['specification', 'architecture'];
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`GET /v1/products/${PRODUCT_ID}`]: { data: draft },
+        [`GET /v1/products/${PRODUCT_ID}/repositories`]: { data: [], nextCursor: null },
+        [`GET /v1/products/${PRODUCT_ID}/setup`]: () => {
+          const body = { data: { inSetup: true, missingDocuments: missing, openChecks: [] } };
+          return { ok: true, status: 200, json: async () => body, text: async () => JSON.stringify(body) };
+        },
+      },
+    });
+    const read = async () =>
+      parseToolResult(await client.callTool({ name: 'taiga_get_product', arguments: { productId: PRODUCT_ID } }))
+        .readiness;
+
+    expect((await read()).nextStep).toMatch(
+      /^The specification comes from the Discovery conversation, held in the web/
+    );
+    missing = ['architecture'];
+    expect((await read()).nextStep).toMatch(/^Still to publish: Architecture\. taiga_generate_product_documents/);
+    missing = [];
+    const done = await read();
+    expect(done.ready).toBe(true);
+    expect(done.nextStep).toMatch(/^Every required document is published: taiga_finish_discovery/);
   });
 
   it('says nothing of where a merged run stopped, whatever its stale status says', async () => {
@@ -6533,9 +6710,7 @@ describe('what the agent review found (PRO-2759)', () => {
       },
     });
 
-    const result = parseToolResult(
-      await client.callTool({ name: 'taiga_get_build', arguments: { buildId: BUILD_ID } })
-    );
+    const result = parseToolResult(await client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } }));
 
     expect(result).not.toHaveProperty('stoppedIn');
   });
@@ -6572,9 +6747,7 @@ describe('what the agent review found (PRO-2759)', () => {
       },
     });
 
-    const result = parseToolResult(
-      await client.callTool({ name: 'taiga_get_build', arguments: { buildId: BUILD_ID } })
-    );
+    const result = parseToolResult(await client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } }));
 
     expect(result.stoppedIn).toMatch(/^after the last step, in hardening/);
   });
@@ -6708,7 +6881,7 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
     });
 
     const item = parseToolResult(
-      await client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+      await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
     );
     expect(item.planFailure).toEqual({
       cause: 'cancelled',
@@ -6725,7 +6898,7 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
       },
     });
     const bare = parseToolResult(
-      await refused.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+      await refused.client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
     );
     expect(bare).toEqual(failed);
 
@@ -6738,7 +6911,7 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
       },
     });
     const staleItem = parseToolResult(
-      await stale.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } })
+      await stale.client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
     );
     expect(staleItem.planFailure).toEqual({
       cause: 'worker_lost',
@@ -6767,7 +6940,9 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
       },
     });
     expect(
-      parseToolResult(await retried.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } }))
+      parseToolResult(
+        await retried.client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+      )
     ).toEqual(failed);
 
     // No failure in the history, or no history reachable: the item as it is.
@@ -6779,7 +6954,9 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
       },
     });
     expect(
-      parseToolResult(await silent.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } }))
+      parseToolResult(
+        await silent.client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+      )
     ).toEqual(failed);
     const offline = await bootMcpPair({
       capabilities: ALL_CAPABILITIES,
@@ -6790,7 +6967,9 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
       },
     });
     expect(
-      parseToolResult(await offline.client.callTool({ name: 'taiga_get_backlog_item', arguments: { itemId: ITEM_ID } }))
+      parseToolResult(
+        await offline.client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+      )
     ).toEqual(failed);
 
     // A plan that did not fail reads no history.
@@ -6798,7 +6977,7 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
       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 } });
+    await planned.client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } });
     expect(planned.fetchSpy.mock.calls.some((c: unknown[]) => String(c[0]).includes('/activity'))).toBe(false);
   });
 
@@ -6865,7 +7044,7 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
         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_queue_initiative')!.description).toMatch(/^Acts on paid/);
     expect(tools.find((t) => t.name === 'taiga_create_factory')!.description).toMatch(/^Writes\. /);
   });
 
@@ -6904,3 +7083,359 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
     expect(standing.controls[0].findingsByTier).toEqual(tiers);
   });
 });
+
+describe('what the third agent review found (PRO-2800)', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('loads the three entry tools upfront in Claude Code, and only those', async () => {
+    const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
+
+    const { tools } = await client.listTools();
+    const upfront = tools.filter((tool) => tool._meta?.['anthropic/alwaysLoad'] === true).map((tool) => tool.name);
+
+    expect(upfront.sort()).toEqual(['taiga_get_product_context', 'taiga_list_action_required', 'taiga_list_products']);
+  });
+
+  it('opens Action Required with what is open by product and kind, rows without their metadata unless asked', async () => {
+    const created = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
+    const rows = [
+      {
+        id: 'i1',
+        productId: PRODUCT_ID,
+        productName: 'Web',
+        kind: 'review_pr',
+        status: 'open',
+        title: 'Review & merge PR #9',
+        createdAt: created,
+        metadata: { prUrl: 'https://github.com/acme/web/pull/9', prNumber: 9 },
+      },
+      {
+        id: 'i2',
+        productId: PRODUCT_ID,
+        productName: 'Web',
+        kind: 'review_doc',
+        status: 'open',
+        createdAt: created,
+        metadata: { decision: { detail: 'x'.repeat(2_000) } },
+      },
+      { id: 'i3', productId: PRODUCT_ID_2, productName: 'Api', kind: 'review_pr', status: 'open', createdAt: created },
+    ];
+    // The API pages: a short page says there is more, so the summary reads up to 100 itself.
+    const inbox = (url: string) => {
+      const limit = Number(new URL(url).searchParams.get('limit') ?? 25);
+      const body = { data: rows.slice(0, limit), nextCursor: limit < rows.length ? 'more' : null, totalCount: 3 };
+      return { ok: true, status: 200, json: async () => body, text: async () => JSON.stringify(body) };
+    };
+    const { client, fetchSpy } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: { 'GET /v1/inbox': inbox },
+    });
+
+    const list = parseToolResult(
+      await client.callTool({ name: 'taiga_list_action_required', arguments: { limit: 2 } })
+    );
+    const full = parseToolResult(
+      await client.callTool({ name: 'taiga_list_action_required', arguments: { full: true } })
+    );
+
+    expect(list.summary).toEqual([
+      { productId: PRODUCT_ID, product: 'Web', open: 2, byKind: { review_pr: 1, review_doc: 1 } },
+      { productId: PRODUCT_ID_2, product: 'Api', open: 1, byKind: { review_pr: 1 } },
+    ]);
+    expect(list.totalCount).toBe(3);
+    expect(list.data[0]).toMatchObject({ id: 'i1', prUrl: 'https://github.com/acme/web/pull/9', waitingDays: 3 });
+    expect(JSON.stringify(list.data)).not.toContain('metadata');
+    expect(full.data[1].metadata).toEqual(rows[1]!.metadata);
+    // The page asked for and the summary's own read, nothing on a later page.
+    const limits = fetchSpy.mock.calls
+      .map((call: unknown[]) => new URL(call[0] as string))
+      .filter((url: URL) => url.pathname === '/v1/inbox')
+      .map((url: URL) => url.searchParams.get('limit'));
+    // The short page and the summary's read; the full page held everything, so it read once.
+    expect(limits).toEqual(['2', '100', null]);
+  });
+
+  it("counts a resolved item's wait up to its resolution", async () => {
+    const day = 24 * 60 * 60 * 1000;
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        'GET /v1/inbox': {
+          data: [
+            {
+              id: 'r1',
+              productId: PRODUCT_ID,
+              kind: 'review_pr',
+              status: 'done',
+              createdAt: new Date(Date.now() - 40 * day).toISOString(),
+              resolvedAt: new Date(Date.now() - 38 * day).toISOString(),
+            },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const archive = parseToolResult(
+      await client.callTool({ name: 'taiga_list_action_required', arguments: { resolved: true } })
+    );
+
+    expect(archive.data[0].waitingDays).toBe(2);
+  });
+
+  it('lists a variable filed under two categories once, naming the other record', async () => {
+    const task = (id: string, category: string, key: string | null) => ({
+      id,
+      productId: PRODUCT_ID,
+      category,
+      key,
+      title: `Set ${key ?? 'something'}`,
+    });
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        'GET /v1/setup-tasks': {
+          data: [
+            task('t1', 'secret', 'JWT_SECRET'),
+            task('t2', 'manual_config', null),
+            task('t3', 'env_var', 'JWT_SECRET'),
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const tasks = parseToolResult(await client.callTool({ name: 'taiga_list_setup_tasks', arguments: {} }));
+
+    expect(tasks.data.map((row: { id: string }) => row.id)).toEqual(['t1', 't2']);
+    expect(tasks.data[0].alsoFiledAs).toEqual([{ id: 't3', category: 'env_var', title: 'Set JWT_SECRET' }]);
+  });
+
+  it('leads a variable with its open record when an older one is done', async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        'GET /v1/setup-tasks': {
+          data: [
+            { id: 't1', productId: PRODUCT_ID, category: 'secret', key: 'K', title: 'Old', inboxItemStatus: 'done' },
+            { id: 't2', productId: PRODUCT_ID, category: 'env_var', key: 'K', title: 'New', inboxItemStatus: 'open' },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const tasks = parseToolResult(
+      await client.callTool({ name: 'taiga_list_setup_tasks', arguments: { includeDone: true } })
+    );
+
+    expect(tasks.data).toHaveLength(1);
+    expect(tasks.data[0]).toMatchObject({ id: 't2', inboxItemStatus: 'open' });
+    expect(tasks.data[0].alsoFiledAs).toEqual([
+      { id: 't1', category: 'secret', title: 'Old', inboxItemStatus: 'done' },
+    ]);
+  });
+
+  it("names a finding's sweep sweepId, so runId stays what taiga_get_run takes", async () => {
+    const FINDING = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4d01';
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        [`GET /v1/maintenance/findings/${FINDING}`]: {
+          data: { id: FINDING, runId: 'sweep-1', remediation: { buildRunId: BUILD_ID } },
+        },
+      },
+    });
+
+    const finding = parseToolResult(
+      await client.callTool({ name: 'taiga_get_finding', arguments: { findingId: FINDING } })
+    );
+
+    expect(finding).toEqual({ sweepId: 'sweep-1', id: FINDING, remediation: { runId: BUILD_ID } });
+  });
+
+  it('says how each run stands in a sentence, and says nothing of a draft where there is no pull request', async () => {
+    const base = { productId: PRODUCT_ID, completedSteps: 6, totalSteps: 6, prDraft: true };
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        [`/v1/products/${PRODUCT_ID}/builds`]: {
+          data: [
+            { ...base, id: 'r1', status: 'closed', prNumber: 28, prUrl: 'https://x/pull/28', prDraft: false },
+            {
+              ...base,
+              id: 'r2',
+              status: 'completed',
+              prMerged: true,
+              prNumber: 7,
+              prUrl: 'https://x/7',
+              baseBranch: 'main',
+            },
+            { ...base, id: 'r3', status: 'failed', failedReason: 'agent_error', completedSteps: 2, prUrl: null },
+            { ...base, id: 'r4', status: 'needs_review', prNumber: 9, prUrl: null },
+            { ...base, id: 'r5', status: 'hardening', prUrl: null },
+            // Merged, but the completion write after the merge failed: the latch decides.
+            {
+              ...base,
+              id: 'r6',
+              status: 'failed',
+              prMerged: true,
+              prNumber: 8,
+              prUrl: 'https://x/8',
+              baseBranch: 'main',
+            },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const runs = parseToolResult(
+      await client.callTool({ name: 'taiga_list_runs', arguments: { productId: PRODUCT_ID } })
+    ).data as Record<string, unknown>[];
+
+    expect(runs.map((run) => [run['disposition'], run['outcome']])).toEqual([
+      ['rejected', 'PR #28 was closed without merging, so the work did not land.'],
+      ['succeeded', 'Merged: PR #7 is in main.'],
+      ['failed', 'Failed: agent_error (2 of 6 steps done).'],
+      ['gated', 'Waiting for a person to review and merge PR #9.'],
+      ['in_flight', 'Running: hardening: running the security scanners and fixing what they find (6 of 6 steps done).'],
+      ['succeeded', 'Merged: PR #8 is in main.'],
+    ]);
+    expect(runs[0]).toHaveProperty('prDraft', false);
+    expect(runs[2]).not.toHaveProperty('prDraft');
+    // A recorded PR number with no URL still has a pull request, and its draft state.
+    expect(runs[3]).toHaveProperty('prDraft', true);
+  });
+
+  it('says where an initiative stands and the call that moves it on, in one sentence', async () => {
+    const item = {
+      id: ITEM_ID,
+      title: 'Add login',
+      status: 'in_progress',
+      state: 'build',
+      needsHumanCause: null,
+      lifecycle: {
+        turn: 'you',
+        stage: 'building',
+        cta: 'retry_build',
+        planFailureCause: null,
+        latestBuild: { status: 'closed', prNumber: 28 },
+      },
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['backlog:read'],
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: item },
+        [`/v1/products/${PRODUCT_ID}/backlog`]: { data: [item], nextCursor: null },
+      },
+    });
+
+    const got = parseToolResult(
+      await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+    );
+    const listed = parseToolResult(
+      await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: PRODUCT_ID } })
+    );
+
+    const said =
+      "Being built; its latest run had its pull request closed without merging (PR #28). A person's turn: a new " +
+      'run starts over from the web; taiga_move_initiative takes it off the line.';
+    expect(got.situation).toBe(said);
+    expect(listed.data[0].situation).toBe(said);
+  });
+
+  it("keeps the run's own reason beside the halt that stopped the line", async () => {
+    const item = {
+      id: ITEM_ID,
+      title: 'Add login',
+      needsHumanCause: 'pr_closed',
+      needsHumanDetail: 'The pull request was closed by alice.',
+      lifecycle: { turn: 'you', stage: 'building', cta: 'retry_build', planFailureCause: null, latestBuild: null },
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['backlog:read'],
+      routes: { [`GET /v1/backlog/${ITEM_ID}`]: { data: item } },
+    });
+
+    const got = parseToolResult(
+      await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+    );
+
+    expect(got.situation).toContain('The pull request was closed by alice.');
+    expect(got.situation).toMatch(/^Being built\. The line stopped on it: .+\. The pull request was closed by alice\./);
+  });
+
+  it("leaves the keys of a document's sections as their writers named them", async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        'GET /v1/tenants/current/documents/policy_security': {
+          data: {
+            id: 'doc-1',
+            type: 'policy_security',
+            version: 1,
+            isDraft: false,
+            data: { version: '1.0.0', sections: { backlogItemId: { content: 'a section by that name' } } },
+          },
+        },
+      },
+    });
+
+    const doc = parseToolResult(
+      await client.callTool({ name: 'taiga_get_document', arguments: { type: 'policy_security' } })
+    );
+
+    expect(Object.keys(doc.data.sections)).toEqual(['backlogItemId']);
+  });
+
+  it("names IDs in refusal details in the product's words", async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`POST /v1/builds/${BUILD_ID}/stop`]: refusal(409, 'CONFLICT', 'Not running', { buildRunId: BUILD_ID }),
+      },
+    });
+
+    const result = await client.callTool({ name: 'taiga_stop_run', arguments: { runId: BUILD_ID } });
+
+    expect(parseToolResult(result).details).toEqual({ runId: BUILD_ID });
+  });
+
+  it('leaves stopping the line to the person when a move meets work in flight', async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`PUT /v1/products/${PRODUCT_ID}/factory`]: refusal(
+          409,
+          'WORK_IN_FLIGHT',
+          'This product is planning right now. Stop the line, then move the product.'
+        ),
+      },
+    });
+
+    const result = await client.callTool({
+      name: 'taiga_move_product',
+      arguments: { productId: PRODUCT_ID, factoryId: FACTORY_ID },
+    });
+
+    expect(result.isError).toBe(true);
+    const said = parseToolResult(result);
+    expect(said.error).toBe('WORK_IN_FLIGHT');
+    expect(said.message).toMatch(/^This product is planning right now\. Moving it now means stopping the line/);
+    expect(said.message).toMatch(/ask the person, and pass stopLine: true only if they say so\.$/);
+    expect(said.message).not.toContain('Stop the line, then');
+  });
+
+  it('fits the server instructions inside what Claude Code keeps', async () => {
+    const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
+
+    const instructions = client.getInstructions() ?? '';
+
+    expect(instructions.length).toBeGreaterThan(500);
+    expect(instructions.length).toBeLessThanOrEqual(2048);
+    expect(instructions).toContain('taiga_get_product_context');
+  });
+});