@taiga-ai/mcp-server 0.21.0-dev.455 → 0.22.0-dev.457

package/src/server.integration.test.ts

@@ -2368,7 +2368,12 @@ describe('MCP server integration', () => {
         `/v1/factories/${FACTORY_ID}/documents`,
         ['factories:read'],
       ],
-      ['taiga_list_initiatives', { productId: PRODUCT_ID }, `/v1/products/${PRODUCT_ID}/backlog`, ['backlog:read']],
+      [
+        'taiga_list_initiatives',
+        { productId: PRODUCT_ID, status: 'all' },
+        `/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({
@@ -7145,7 +7150,8 @@ describe('what the third agent review found (PRO-2800)', () => {
     expect(list.data[0]).not.toHaveProperty('stale');
     expect(list.data[1].stale).toBe('its initiative was canceled; the pull request is still open on the forge');
     expect(list.summary).toEqual([
-      { productId: PRODUCT_ID, product: 'Web', open: 2, byKind: { review_pr: 2 }, stale: 1 },
+      // The stale one is counted apart: open and byKind are what still stands.
+      { productId: PRODUCT_ID, product: 'Web', open: 1, byKind: { review_pr: 1 }, stale: 1 },
     ]);
   });
 
@@ -7218,7 +7224,7 @@ describe('what the third agent review found (PRO-2800)', () => {
     const list = parseToolResult(await client.callTool({ name: 'taiga_list_action_required', arguments: {} }));
 
     expect(list.data[0]).not.toHaveProperty('stale');
-    expect(list.staleNote).toMatch(/^1 pull request review was not checked for staleness/);
+    expect(list.staleNote).toMatch(/^1 review was not checked for staleness/);
   });
 
   it('names factories past the first page of them', async () => {
@@ -8028,6 +8034,325 @@ describe('what the fourth agent review found (PRO-2800)', () => {
     expect(runs[0]!['disposition']).toBe('in_flight');
   });
 
+  it('marks a Review Initiatives item stale when nothing is left in the backlog, and keeps review rows lean', async () => {
+    const OTHER = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f05';
+    const ask = (id: string, productId: string) => ({
+      id,
+      productId,
+      productName: id,
+      kind: 'review_backlog',
+      subjectType: 'product',
+      subjectId: productId,
+      title: 'Review Initiatives',
+      summary: 'Initiatives were generated for this product.',
+      status: 'open',
+      createdAt: new Date().toISOString(),
+    });
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read', 'backlog:read'],
+      routes: {
+        'GET /v1/inbox': {
+          data: [
+            ask('emptied', PRODUCT_ID),
+            ask('waiting', OTHER),
+            {
+              id: 'pr',
+              productId: OTHER,
+              kind: 'review_pr',
+              subjectType: 'pull_request',
+              subjectId: 'x',
+              title: 'Review & merge PR #3',
+              summary: 'The coding agent finished its turn on a/b. Review PR #3, then merge.',
+              status: 'open',
+              createdAt: new Date().toISOString(),
+            },
+          ],
+          nextCursor: null,
+        },
+        [`GET /v1/products/${PRODUCT_ID}/backlog`]: { data: [], nextCursor: null },
+        [`GET /v1/products/${OTHER}/backlog`]: { data: [{ id: 'b1', status: 'backlog' }], nextCursor: null },
+      },
+    });
+
+    const list = parseToolResult(await client.callTool({ name: 'taiga_list_action_required', arguments: {} }));
+    const full = parseToolResult(
+      await client.callTool({ name: 'taiga_list_action_required', arguments: { full: true } })
+    );
+
+    expect(list.data.map((row: { id: string; stale?: string }) => [row.id, row.stale ?? null])).toEqual([
+      ['emptied', 'no initiative is open now: the ones it asked about are all done or canceled'],
+      ['waiting', null],
+      ['pr', null],
+    ]);
+    expect(list.data[2]).not.toHaveProperty('summary');
+    expect(list.data[0].summary).toBe('Initiatives were generated for this product.');
+    expect(full.data[2].summary).toMatch(/^The coding agent finished its turn/);
+  });
+
+  it('says when a check failed after every step, docs-only steps included', async () => {
+    const step = (order: number, files: string[], tests: string) => ({
+      id: `s${order}`,
+      stepOrder: order,
+      title: `Step ${order}`,
+      status: 'completed',
+      filesChanged: files,
+      summary: 'Done.',
+      verification: [
+        { check: 'format', status: 'passed' },
+        { check: 'tests', status: tests },
+      ],
+    });
+    const run = { id: BUILD_ID, productId: PRODUCT_ID, status: 'needs_review', prState: 'open' };
+    const boot = (steps: unknown[]) =>
+      bootMcpPair({
+        capabilities: ['products:read'],
+        routes: { [`/v1/builds/${BUILD_ID}`]: { data: run }, [`/v1/builds/${BUILD_ID}/steps`]: { data: steps } },
+      });
+
+    // One pair at a time: each boot replaces the fetch routes.
+    const always = await boot([step(1, ['src/a.rs'], 'failed'), step(2, ['README.md'], 'failed')]);
+    const said = parseToolResult(
+      await always.client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } })
+    );
+    const once = await boot([step(1, ['src/a.rs'], 'failed'), step(2, ['src/b.rs'], 'passed')]);
+    const quiet = parseToolResult(
+      await once.client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } })
+    );
+
+    expect(said.verificationNote).toBe(
+      "Taiga's tests check failed after every checked step (1 to 2), including step 2, which changed only " +
+        'documentation. A check failing from the first step on is usually one the repository or the check ' +
+        "environment fails throughout, not one each step broke. It records no reason; each step's headline says " +
+        'what its own run found.'
+    );
+    expect(quiet).not.toHaveProperty('verificationNote');
+
+    // A code file named like a document is code: README.ts is not a docs-only step.
+    const named = await boot([step(1, ['src/a.rs'], 'failed'), step(2, ['README.ts'], 'failed')]);
+    const coded = parseToolResult(
+      await named.client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } })
+    );
+    expect(coded).not.toHaveProperty('verificationNote');
+
+    // Two code steps both failing may be two breakages: no note. Three, with a reason, say the reason.
+    const two = await boot([step(1, ['src/a.rs'], 'failed'), step(2, ['src/b.rs'], 'failed')]);
+    const pair = parseToolResult(await two.client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } }));
+    expect(pair).not.toHaveProperty('verificationNote');
+    const scoped = (order: number) => ({
+      ...step(order, [`src/${order}.rs`], 'failed'),
+      verification: [{ check: 'tests', status: 'failed', reason: 'scoped to tests/x; CI runs the full suite' }],
+    });
+    const three = await boot([scoped(1), scoped(2), scoped(3)]);
+    const triple = parseToolResult(
+      await three.client.callTool({ name: 'taiga_get_run', arguments: { runId: BUILD_ID } })
+    );
+    expect(triple.verificationNote).toMatch(/Its reason: scoped to tests\/x; CI runs the full suite\.$/);
+  });
+
+  it('counts a Review Initiatives item it could not check once, as unchecked', async () => {
+    const ask = {
+      id: 'ask',
+      productId: PRODUCT_ID,
+      kind: 'review_backlog',
+      subjectType: 'product',
+      subjectId: PRODUCT_ID,
+      title: 'Review Initiatives',
+      status: 'open',
+      createdAt: new Date().toISOString(),
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: { 'GET /v1/inbox': { data: [ask], nextCursor: null } },
+    });
+
+    const list = parseToolResult(await client.callTool({ name: 'taiga_list_action_required', arguments: {} }));
+
+    expect(list.data[0]).not.toHaveProperty('stale');
+    expect(list.staleNote).toMatch(/^1 review was not checked for staleness/);
+  });
+
+  it('looks for a taken product name in its own factory only, and leaves the choice to the person', async () => {
+    const { client, fetchSpy } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        'GET /v1/products': {
+          data: [{ id: PRODUCT_ID, name: 'Web', slug: 'web', createdAt: '2026-10-10T10:00:00Z' }],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const refused = parseToolResult(
+      await client.callTool({
+        name: 'taiga_create_product',
+        arguments: { factoryId: FACTORY_ID, name: 'web', start: 'scratch' },
+      })
+    );
+
+    const listed = fetchSpy.mock.calls
+      .map((call: unknown[]) => String(call[0]))
+      .find((url: string) => url.includes('/v1/products?'));
+    expect(new URL(listed!).searchParams.get('factoryId')).toBe(FACTORY_ID);
+    expect(refused.message).toBe(
+      `A product named "Web" already exists in this factory (${PRODUCT_ID}, created 2026-10-10T10:00:00Z). It may ` +
+        "not be this person's: ask whether they meant that one, want another name, or want a second " +
+        '(allowDuplicateName: true).'
+    );
+    expect(refused.message).not.toMatch(/Use it/);
+  });
+
+  it('names a factory ID passed where a product ID belongs, and drops the transport text from a miss', async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read', 'backlog:read', 'factories:read'],
+      routes: {
+        [`/v1/products/${FACTORY_ID}/backlog`]: refusal(404, 'NOT_FOUND', 'Product not found'),
+        [`GET /v1/products/${FACTORY_ID}`]: refusal(404, 'NOT_FOUND', 'Product not found'),
+        [`GET /v1/factories/${FACTORY_ID}`]: { data: { id: FACTORY_ID, name: 'Platform', slug: 'platform' } },
+      },
+    });
+
+    const listed = parseToolResult(
+      await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: FACTORY_ID } })
+    );
+    const read = parseToolResult(
+      await client.callTool({ name: 'taiga_get_product', arguments: { productId: FACTORY_ID } })
+    );
+
+    expect(listed.message).toMatch(
+      /That ID is the factory "Platform", not a product: taiga_list_products with factoryId/
+    );
+    expect(read.message).not.toMatch(/404|NOT_FOUND/);
+    expect(read.message).toMatch(/That ID is the factory "Platform"/);
+  });
+
+  it('says what a setup product needs after a repository link, and how to swap a linked one', async () => {
+    const LINK = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f06';
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`POST /v1/products/${PRODUCT_ID}/repositories`]: {
+          data: { id: LINK, fullName: 'acme/web', baseBranch: null },
+        },
+        [`GET /v1/products/${PRODUCT_ID}`]: {
+          data: { id: PRODUCT_ID, name: 'Web', status: 'draft', settings: { projectType: 'brownfield' } },
+        },
+      },
+    });
+    const linked = parseToolResult(
+      await client.callTool({
+        name: 'taiga_link_repository',
+        arguments: { productId: PRODUCT_ID, githubRepositoryId: '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f07' },
+      })
+    );
+    expect(linked.readiness?.nextStep).toEqual(expect.any(String));
+
+    const { client: second } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        [`POST /v1/products/${PRODUCT_ID}/repositories`]: refusal(
+          409,
+          'CONFLICT',
+          'This product already has a repository. Change it instead of linking another.'
+        ),
+      },
+    });
+    const refused = parseToolResult(
+      await second.callTool({
+        name: 'taiga_link_repository',
+        arguments: { productId: PRODUCT_ID, githubRepositoryId: '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f07' },
+      })
+    );
+    expect(refused.message).toBe(
+      'This product already has a repository. Pass replacesRepositoryId to swap it in one step, or ' +
+        'taiga_unlink_repository first (taiga_list_product_repositories gives its ID).'
+    );
+  });
+
+  it('says a dependency with no fixed version cannot be fixed, and keeps the advisory to what an agent reads', async () => {
+    const FINDING = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f08';
+    const finding = {
+      id: FINDING,
+      kind: 'vulnerable_dependency',
+      packageName: 'rsa',
+      recommendedVersion: null,
+      remediableBy: 'coding_agent',
+      runId: 'sweep-1',
+      data: {
+        id: 'RUSTSEC-2023-0071',
+        summary: 'Marvin attack',
+        details: 'd'.repeat(4_000),
+        affected: [{ ranges: [] }],
+        references: [1, 2, 3, 4, 5].map((n) => ({ url: `https://x/${n}` })),
+        schema_version: '1.4',
+      },
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        [`GET /v1/maintenance/findings/${FINDING}`]: { data: finding },
+        [`/v1/products/${PRODUCT_ID}/maintenance/findings`]: { data: [finding], nextCursor: null },
+      },
+    });
+
+    const one = parseToolResult(
+      await client.callTool({ name: 'taiga_get_finding', arguments: { findingId: FINDING } })
+    );
+    const whole = parseToolResult(
+      await client.callTool({ name: 'taiga_get_finding', arguments: { findingId: FINDING, full: true } })
+    );
+    const rows = parseToolResult(
+      await client.callTool({ name: 'taiga_list_findings', arguments: { productId: PRODUCT_ID } })
+    );
+
+    expect(one.fixable).toBe(false);
+    expect(one.fixNote).toMatch(/taiga_fix_finding refuses it/);
+    expect(Object.keys(one.data).sort()).toEqual(['details', 'id', 'references', 'referencesNote', 'summary']);
+    expect(one.data.details).toMatch(/cut at 1500 of 4000 characters/);
+    expect(one.data.references).toHaveLength(3);
+    expect(whole.data.affected).toEqual([{ ranges: [] }]);
+    expect(rows.data[0].fixable).toBe(false);
+  });
+
+  it('says "an" before an ID kind that starts with a vowel', async () => {
+    const { client } = await bootMcpPair({ capabilities: ['backlog:read'] });
+
+    const result = await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: 'my item' } });
+
+    expect(JSON.stringify(result.content)).toMatch(/An initiative ID is a UUID/);
+  });
+
+  it('lists only open initiatives unless asked for every one', async () => {
+    const row = (id: string, status: string) => ({
+      id,
+      title: id,
+      status,
+      state: status === 'in_progress' ? 'build' : status,
+    });
+    const body = {
+      data: [row('a', 'backlog'), row('b', 'done'), row('c', 'in_progress'), row('d', 'canceled')],
+      nextCursor: null,
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['backlog:read'],
+      routes: { [`/v1/products/${PRODUCT_ID}/backlog`]: body },
+    });
+
+    const open = parseToolResult(
+      await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: PRODUCT_ID } })
+    );
+    const all = parseToolResult(
+      await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: PRODUCT_ID, status: 'all' } })
+    );
+    const paged = await client.callTool({
+      name: 'taiga_list_initiatives',
+      arguments: { productId: PRODUCT_ID, cursor: 'p2' },
+    });
+
+    expect(open.data.map((item: { id: string }) => item.id)).toEqual(['a', 'c']);
+    expect(all.data.map((item: { id: string }) => item.id)).toEqual(['a', 'b', 'c', 'd']);
+    expect(parseToolResult(paged)).toMatchObject({ error: 'VALIDATION_ERROR' });
+  });
+
   it('splits the ask-first notice into paid agent work and what others see, in whoami too', async () => {
     const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 

package/src/tools/backlogs.ts

@@ -22,16 +22,7 @@ import { jobReport } from './jobs.js';
 import { requestPrompt } from './request-prompt.js';
 import { queueView } from './queue.js';
 import { handbackNextStep, handbackSaid, landedDisposition } from './builds.js';
-import {
-  SEARCH_NOTE,
-  SEARCH_PAGE_SIZE,
-  SEARCH_WITH_CURSOR,
-  criteriaCounts,
-  itemRows,
-  page,
-  pickFields,
-  searchPages,
-} from './summarize.js';
+import { SEARCH_PAGE_SIZE, criteriaCounts, itemRows, page, pickFields, searchPages } from './summarize.js';
 
 /** What a list row needs to say for the model to pick an item to read in full. */
 export const BACKLOG_SUMMARY_FIELDS = [
@@ -304,11 +295,12 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
     {
       title: 'List initiatives',
       description:
-        "List a product's initiatives: title, category, status, place on the line (backlog, todo, queue, plan, " +
-        'build, done), situation (where it stands and what moves it on) and criteria (acceptance criteria met, ' +
-        'confirmed with evidence or checked off by a person; null before planning, so a done initiative can show ' +
-        'fewer met than it has). query finds one by title; taiga_get_initiative reads it in full. Archived ones ' +
-        'are left out unless asked for.',
+        "List a product's open initiatives (not done or canceled; status: 'all' for every one): title, " +
+        'category, status, place on the line (backlog, todo, queue, plan, build, done), situation (where it ' +
+        'stands and what moves it on) and criteria (acceptance criteria met, confirmed with evidence or checked ' +
+        'off by a person; null before planning, so a done initiative can show fewer met than it has). query ' +
+        'finds one by title, state one board column; taiga_get_initiative reads it in full. Archived ones are ' +
+        'left out unless asked for.',
       inputSchema: z.object({
         productId,
         query: z
@@ -319,9 +311,11 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
           .optional()
           .describe('Part of the title, any case: only the items that contain it'),
         status: z
-          .enum(['backlog', 'in_progress', 'done', 'canceled'])
+          .enum(['open', 'all', 'backlog', 'in_progress', 'done', 'canceled'])
           .optional()
-          .describe('Only items with this status; in_progress covers everything between backlog and done'),
+          .describe(
+            'open (default without state): not done or canceled; all: every one; in_progress covers everything between backlog and done'
+          ),
         planningStatus: z
           .enum(['unplanned', 'planning', 'planned', 'failed'])
           .optional()
@@ -340,45 +334,39 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () => {
-        const { query, state, ...filters } = params;
-        // The API filters by status only; a board column is read across pages here (PRO-2800).
-        if (state !== undefined) {
-          if (params.cursor !== undefined) {
-            return toolError(
-              'VALIDATION_ERROR',
-              'A board-column filter answers one page; narrow it with status or query.'
-            );
-          }
-          const found = await searchPages(
-            (cursor) => client.listBacklogItems(params.productId, { ...filters, limit: SEARCH_PAGE_SIZE, cursor }),
-            query ?? '',
-            (row) => [row.title],
-            params.limit ?? 25,
-            (row) => row.state === state
-          );
-          return toolResult({
-            ...page(situatedRows(found.rows), null),
-            ...(found.more
-              ? { more: 'More items may be in that column: narrow it with status or query, or raise the limit.' }
-              : {}),
-          });
-        }
-        if (query === undefined) {
-          const result = await client.listBacklogItems(params.productId, filters);
+        const { query, state, status = state === undefined ? 'open' : 'all', ...filters } = params;
+        // Two reviews asked "what is in the backlog" and got the whole history, done and canceled first
+        // (PRO-2800): open is the default. The API filters by one status only, so open, a board column and a
+        // title are read across pages here.
+        const apiFilters = { ...filters, status: status === 'open' || status === 'all' ? undefined : status };
+        const open = status === 'open';
+        if (query === undefined && state === undefined && !open) {
+          const result = await client.listBacklogItems(params.productId, apiFilters);
           return toolResult(page(situatedRows(result.data as Record<string, unknown>[]), result.nextCursor));
         }
         if (params.cursor !== undefined) {
-          return toolError('VALIDATION_ERROR', SEARCH_WITH_CURSOR);
+          return toolError(
+            'VALIDATION_ERROR',
+            "Open items, a board column or a title search answer one page; narrow them, or pass status: 'all' " +
+              '(or one status) to page through every item.'
+          );
         }
         const found = await searchPages(
-          (cursor) => client.listBacklogItems(params.productId, { ...filters, limit: SEARCH_PAGE_SIZE, cursor }),
-          query,
+          (cursor) => client.listBacklogItems(params.productId, { ...apiFilters, limit: SEARCH_PAGE_SIZE, cursor }),
+          query ?? '',
           (row) => [row.title],
-          params.limit ?? 25
+          params.limit ?? 25,
+          (row) => (state === undefined || row.state === state) && (!open || !['done', 'canceled'].includes(row.status))
         );
         return toolResult({
           ...page(situatedRows(found.rows), null),
-          ...(found.more ? { more: SEARCH_NOTE } : {}),
+          ...(found.more
+            ? {
+                more:
+                  'There may be more than the limit carries: narrow it with state or query, or list one status ' +
+                  '(backlog, in_progress, done or canceled) without them, which pages.',
+              }
+            : {}),
         });
       })
   );

package/src/tools/builds.ts

@@ -309,6 +309,54 @@ export function withInitiativeState(
   };
 }
 
+/** A step that changed only prose: no code of its own could have broken a test. */
+const PROSE_ONLY = /(^|\/)(README|CHANGELOG|LICENSE|NOTICE|AUTHORS)$|\.(md|mdx|txt|rst|adoc)$/i;
+
+/**
+ * What a check that failed after every step means (PRO-2800). Two reviews read
+ * seven steps of "tests: failed" as seven breakages, while the headlines said
+ * each step's own tests passed: a check that fails from the first step on,
+ * docs-only steps included, is one the repository or the check environment
+ * carries throughout. The check records no reason, so this says what the
+ * pattern shows and no more.
+ */
+export function verificationNote(steps: Record<string, unknown>[]): string | null {
+  const checked = steps.filter((step) => Array.isArray(step['verification']) && step['verification'].length > 0);
+  if (checked.length < 2) return null;
+  type Check = { check?: unknown; status?: unknown; reason?: unknown };
+  const failedOn = (step: Record<string, unknown>) =>
+    (step['verification'] as Check[]).filter((check) => check.status === 'failed').map((check) => String(check.check));
+  const always = failedOn(checked[0]!).filter((check) => checked.every((step) => failedOn(step).includes(check)));
+  if (always.length === 0) return null;
+  const prose = checked.find((step) => {
+    const files = step['filesChanged'];
+    return Array.isArray(files) && files.length > 0 && files.every((file) => PROSE_ONLY.test(String(file)));
+  });
+  // Two code steps both failing may be two real breakages; the pattern needs three, or a step with no code.
+  if (!prose && checked.length < 3) return null;
+  const reasons = [
+    ...new Set(
+      checked.flatMap((step) =>
+        (step['verification'] as Check[])
+          .filter((check) => check.status === 'failed' && always.includes(String(check.check)))
+          .map((check) => check.reason)
+          .filter((reason): reason is string => typeof reason === 'string' && reason.length > 0)
+      )
+    ),
+  ];
+  const first = checked[0]!['stepOrder'];
+  const last = checked[checked.length - 1]!['stepOrder'];
+  const proseSaid = prose ? `, including step ${String(prose['stepOrder'])}, which changed only documentation` : '';
+  return (
+    `Taiga's ${always.join(' and ')} check failed after every checked step (${String(first)} to ${String(last)})` +
+    `${proseSaid}. A check failing from the first step on is usually one the repository or the check ` +
+    'environment fails throughout, not one each step broke. ' +
+    (reasons.length > 0
+      ? `Its reason${reasons.length === 1 ? '' : 's'}: ${reasons.slice(0, 3).join('; ')}.`
+      : "It records no reason; each step's headline says what its own run found.")
+  );
+}
+
 /** readableRun for a list row. */
 export const readableRow = (run: Record<string, unknown>) => readableRun(run, { row: true });
 
@@ -493,10 +541,13 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
         const stop = where ? { stoppedIn: where } : {};
         const states = await initiativeStates(client, [runRow as unknown as Record<string, unknown>]);
         const readable = withInitiativeState(readableRun(runRow), states);
-        if (params.full) return toolResult({ ...readable, ...stop, steps: steps.data });
+        const note = verificationNote(rows as unknown as Record<string, unknown>[]);
+        const verification = note ? { verificationNote: note } : {};
+        if (params.full) return toolResult({ ...readable, ...stop, ...verification, steps: steps.data });
         return toolResult({
           ...readable,
           ...stop,
+          ...verification,
           steps: pickFields(rows, STEP_SUMMARY_FIELDS).map((step, index) => ({
             ...step,
             headline: summaryHeadline(rows[index]!.summary),

package/src/tools/context.ts

@@ -245,7 +245,7 @@ async function documentsPart(client: TaigaClient, product: WithoutTenant<Product
   return { ...out, notes };
 }
 
-/** Every published policy as its section ids, so the model knows which one to read with taiga_get_document. */
+/** Every published policy with its section count, so the model knows which one to read with taiga_get_document. */
 async function policiesPart(client: TaigaClient) {
   const rows = (await client.listTenantDocuments({ limit: 100 })).data as Record<string, unknown>[];
   // Each policy with how many sections it has, not their ids: the same for every product, and about a fifth of
@@ -471,7 +471,7 @@ export function registerContextTools(server: McpServer, client: TaigaClient) {
         'Read where a product stands in one call; the first read for any product question. Name it by ID, slug ' +
         'or git remote URL. Returns product (in setup, readiness and next move), factory with its instructions, ' +
         'specification and architecture outlines (section ids, sizes), policies with section counts, open ' +
-        'initiatives (taiga_list_initiatives has the done and canceled), repositories, the latest ten runs, and counts for Action Required, open findings and ' +
+        "initiatives (taiga_list_initiatives status: 'all' has the done and canceled), repositories, the latest ten runs, and counts for Action Required, open findings and " +
         'policy violations. A part that failed is under unavailable, one the key cannot read under notGranted; ' +
         `neither shows as empty. documents: budget returns whole sections up to about ${DOCUMENT_BUDGET / 1000}k ` +
         'characters each, full returns all.',

package/src/tools/errors.ts

@@ -40,11 +40,19 @@ export function inProductWords(value: unknown): unknown {
 
 /** The API's 404 sentence in the product's words: "Backlog item not found" is an initiative not found. */
 export function inProductWording(said: string): string {
-  return said
-    .replace(/^Backlog item not found/i, 'Initiative not found')
-    .replace(/^Build run step not found/i, 'Run step not found')
-    .replace(/^Build run not found/i, 'Run not found')
-    .replace(/^Custom document not found/i, 'Knowledge file not found');
+  return (
+    said
+      .replace(/^Backlog item not found/i, 'Initiative not found')
+      .replace(/^Build run step not found/i, 'Run step not found')
+      .replace(/^Build run not found/i, 'Run not found')
+      .replace(/^Custom document not found/i, 'Knowledge file not found')
+      // The API's word for a second link names no way out; the tool has two.
+      .replace(
+        /^This product already has a repository\. Change it instead of linking another\./i,
+        'This product already has a repository. Pass replacesRepositoryId to swap it in one step, or ' +
+          'taiga_unlink_repository first (taiga_list_product_repositories gives its ID).'
+      )
+  );
 }
 
 /** A successful tool result: one JSON text block the model reads. */
@@ -129,7 +137,8 @@ export async function runTool(handler: () => Promise<CallToolResult>): Promise<C
       const code = error.code ?? CODE_BY_STATUS[error.status] ?? 'API_ERROR';
       const said = error.apiMessage ?? `Taiga API answered ${error.status}.`;
       // A miss says where the right IDs are (hints.ts): the API's own word is bare.
-      const message = error.status === 404 ? withNotFoundHint(inProductWording(said)) : said;
+      const worded = inProductWording(said);
+      const message = error.status === 404 ? withNotFoundHint(worded) : worded;
       return toolError(code, message, error.details);
     }
     if (isNetworkFailure(error)) {