@taiga-ai/mcp-server 0.25.0-dev.466 → 0.25.0-dev.467

package/dist/index.js

@@ -3781,20 +3781,27 @@ const INITIATIVE_CHECKS = 10;
 * The status of the initiative behind each run still waiting on its pull
 * request (PRO-2800). A reviewing agent read a run of a canceled initiative as
 * "waiting for a person to review and merge" while Action Required called the
-* same review stale. A 404 is 'deleted'. Best effort: an initiative past the
-* cap, one whose read failed, and every one without backlog:read is
-* 'unchecked', which withInitiativeState adds to the row's outcome.
+* same review stale.
+*
+* The run says it itself since PRO-2808 (initiativeClosed: done, canceled,
+* archived, deleted, or null while live), for every key that can read it.
+* Against an API from before that, each initiative is read: a 404 is
+* 'deleted', and an initiative past the cap, one whose read failed, and every
+* one without backlog:read is 'unchecked', which withInitiativeState adds to
+* the row's outcome.
 */
 async function initiativeStates(client, rows) {
 	const states = /* @__PURE__ */ new Map();
 	const waiting = rows.filter((row) => ["needs_review", "completed"].includes(String(row["status"])) && row["prMerged"] !== true);
-	const all = [...new Set(waiting.map((row) => row["backlogItemId"]).filter((id) => typeof id === "string"))];
+	const told = waiting.filter((row) => "initiativeClosed" in row);
+	for (const row of told) if (typeof row["backlogItemId"] === "string") states.set(row["backlogItemId"], typeof row["initiativeClosed"] === "string" ? row["initiativeClosed"] : "live");
+	const all = [...new Set(waiting.filter((row) => !("initiativeClosed" in row)).map((row) => row["backlogItemId"]).filter((id) => typeof id === "string" && !states.has(id)))];
 	const ids = client.hasCapability("backlog:read") ? all.slice(0, INITIATIVE_CHECKS) : [];
 	for (const id of all) if (!ids.includes(id)) states.set(id, "unchecked");
 	await Promise.all(ids.map(async (id) => {
 		try {
 			const item = (await client.getBacklogItem(id)).data;
-			states.set(id, String(item["status"] ?? item["state"]));
+			states.set(id, item["archivedAt"] ? "archived" : String(item["status"] ?? item["state"]));
 		} catch (error) {
 			if (error instanceof TaigaApiError && error.status === 404) return void states.set(id, "deleted");
 			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
@@ -3803,7 +3810,18 @@ async function initiativeStates(client, rows) {
 	}));
 	return states;
 }
-/** A readable run row that also says when its initiative was canceled or deleted while its pull request waited. */
+/**
+* How each way an initiative ends reads on a run it left waiting: the same set
+* Action Required closes a run's review for (PRO-2806). A done one's waiting
+* run is not the one that landed it: that run is merged and never waiting.
+*/
+const INITIATIVE_ENDED = {
+	done: "was marked done",
+	canceled: "was canceled",
+	archived: "was archived",
+	deleted: "was deleted"
+};
+/** A readable run row that also says when its initiative ended while its pull request waited. */
 function withInitiativeState(row, states) {
 	const state = states.get(String(row["backlogItemId"]));
 	if (!["gated", "unmerged"].includes(String(row["disposition"]))) return row;
@@ -3811,14 +3829,15 @@ function withInitiativeState(row, states) {
 		...row,
 		outcome: `${String(row["outcome"])} Whether its initiative still wants it was not checked.`
 	};
-	if (state !== "canceled" && state !== "deleted") return row;
+	const ended = state ? INITIATIVE_ENDED[state] : void 0;
+	if (!ended) return row;
 	const pr = typeof row["prNumber"] === "number" ? `PR #${row["prNumber"]}` : "its pull request";
 	const open = row["prState"] === "open" ? ` ${pr} is still open on the forge.` : "";
 	return {
 		...row,
 		disposition: "abandoned",
 		actions: [],
-		outcome: `Its initiative was ${state}, so nobody is waiting on this run.${open}`
+		outcome: `Its initiative ${ended}, so nobody is waiting on this run.${open}`
 	};
 }
 /** A step that changed only prose: no code of its own could have broken a test. */
@@ -3925,7 +3944,7 @@ function registerBuildTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
 	server.registerTool("taiga_list_runs", {
 		title: "List runs",
-		description: "List coding agent runs, newest first: branch, pull request, step progress, outcome (one sentence), actions and disposition: in_flight, gated (a person owes a review and merge), succeeded (merged), failed, stopped, rejected (pull request closed unmerged), unmerged, or abandoned (initiative canceled or deleted). Without productId, every product's runs; active: true keeps running ones. taiga_get_run reads one; carry work on from the initiative (taiga_resume_initiative).",
+		description: "List coding agent runs, newest first: branch, pull request, step progress, outcome (one sentence), actions and disposition: in_flight, gated (a person owes a review and merge), succeeded (merged), failed, stopped, rejected (pull request closed unmerged), unmerged, or abandoned (its initiative ended: done, canceled, archived or deleted). Without productId, every product's runs; active: true keeps running ones. taiga_get_run reads one; carry work on from the initiative (taiga_resume_initiative).",
 		inputSchema: z.object({
 			productId: productId.optional(),
 			initiativeId: idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it").optional().describe("Only this initiative's runs -- get from taiga_list_initiatives; needs productId"),
@@ -21420,41 +21439,29 @@ const MISSING_DOCUMENTS_HOW = "An imported product gets them from its import (ta
 /**
 * Refuse a name already taken (PRO-2800): the API appends -2 to the slug and
 * creates a second one, so a retried call or two agents at once left
-* duplicates nobody asked for. allowDuplicateName says the person means it.
+* duplicates nobody asked for. The API checks it in the create's transaction
+* (PRO-2808), so names past any page and two creates at once are caught too.
+* allowDuplicateName says the person means it.
 */
 const allowDuplicateName = z.boolean().optional().describe("Create it even when one with the same name exists (default false: refused, naming the existing one)");
-/** The same name, as a person would read it: case and surrounding space aside. */
-const sameName = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
-/** Pages read looking for a taken name; past this the create goes ahead. */
-const NAME_PAGES = 5;
-/**
-* The first row with this name, across pages. Best effort: a list the API
-* refuses or fails leaves the check out rather than the create.
-*/
-async function firstNamed(name, read) {
-	let cursor;
-	try {
-		for (let pageIndex = 0; pageIndex < NAME_PAGES; pageIndex += 1) {
-			const result = await read(cursor);
-			const same = result.data.find((row) => sameName(row.name, name));
-			if (same) return same;
-			if (!result.nextCursor) return null;
-			cursor = result.nextCursor;
-		}
-	} catch (error) {
-		if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
-	}
-	return null;
-}
 /**
-* The refusal names the one that exists and leaves the choice to the person: another session may have made it, so
-* "use it" would hand the agent someone else's work (PRO-2800, review 6).
-*/
-function duplicateName(kind, existing, where) {
-	const made = typeof existing.createdAt === "string" ? `, created ${existing.createdAt}` : "";
-	return toolError("DUPLICATE_NAME", `A ${kind} named "${existing.name}" already exists ${where} (${existing.id}${made}). It may not be this person's: ask whether they meant that one, want another name, or want a second (allowDuplicateName: true).`, {
-		existingId: existing.id,
-		...existing.slug ? { existingSlug: existing.slug } : {}
+* The API's refusal of a taken name, as the tool's: it names the one that
+* exists when the caller may read it, and leaves the choice to the person.
+* Another session may have made it, so "use it" would hand the agent someone
+* else's work (PRO-2800, review 6). Anything else is not this refusal.
+*/
+function duplicateName(kind, error, where) {
+	if (!(error instanceof TaigaApiError) || error.status !== 409 || error.details?.["reason"] !== "duplicate_name") return null;
+	const said = (key) => typeof error.details?.[key] === "string" ? error.details[key] : void 0;
+	const [existingId, existingSlug, name, createdAt] = [
+		said("existingId"),
+		said("existingSlug"),
+		said("existingName"),
+		said("existingCreatedAt")
+	];
+	return toolError("DUPLICATE_NAME", `${name ? `A ${kind} named "${name}"` : `A ${kind} with this name`} already exists ${where}${existingId ? ` (${existingId}${createdAt ? `, created ${createdAt}` : ""})` : ""}. ${existingId ? "It may not be this person's: ask whether they meant that one, want another name, or want a second" : "The caller cannot read it: ask whether they want another name or a second"} (allowDuplicateName: true).`, {
+		...existingId ? { existingId } : {},
+		...existingSlug ? { existingSlug } : {}
 	});
 }
 /** A product row the model can act on: how it started, and while in setup what it still needs. */
@@ -21495,14 +21502,16 @@ function registerSetupTools(server, client) {
 			}),
 			annotations: WRITE
 		}, (params) => runTool(async () => {
-			if (!params.allowDuplicateName) {
-				const same = await firstNamed(params.name, async (cursor) => client.listFactories({
-					limit: 100,
-					cursor
-				}));
-				if (same) return duplicateName("factory", same, "in this organization");
+			try {
+				return toolResult(pickFields([(await client.createFactory({
+					name: params.name,
+					refuseDuplicateName: !params.allowDuplicateName
+				})).data], FACTORY_FIELDS)[0]);
+			} catch (error) {
+				const refused = duplicateName("factory", error, "in this organization");
+				if (refused) return refused;
+				throw error;
 			}
-			return toolResult(pickFields([(await client.createFactory({ name: params.name })).data], FACTORY_FIELDS)[0]);
 		}));
 		server.registerTool("taiga_rename_factory", {
 			title: "Rename a factory",
@@ -21567,22 +21576,22 @@ function registerSetupTools(server, client) {
 	}, (params) => runTool(async () => {
 		const contradiction = notesWithNothingToDescribe(params);
 		if (contradiction) return contradiction;
-		if (!params.allowDuplicateName) {
-			const same = await firstNamed(params.name, async (cursor) => client.listProducts({
+		let product;
+		try {
+			product = (await client.createProduct({
+				name: params.name,
 				factoryId: params.factoryId,
-				limit: 100,
-				cursor
-			}));
-			if (same) return duplicateName("product", same, "in this factory");
+				...params.start === "import" ? { projectType: "brownfield" } : {},
+				...params.ownsInfrastructure !== void 0 ? { ownsInfrastructure: params.ownsInfrastructure } : {},
+				...params.ownsDeployment !== void 0 ? { ownsDeployment: params.ownsDeployment } : {},
+				...params.deploymentNotes !== void 0 ? { deploymentNotes: params.deploymentNotes } : {},
+				refuseDuplicateName: !params.allowDuplicateName
+			})).data;
+		} catch (error) {
+			const refused = duplicateName("product", error, "in this factory");
+			if (refused) return refused;
+			throw error;
 		}
-		const product = (await client.createProduct({
-			name: params.name,
-			factoryId: params.factoryId,
-			...params.start === "import" ? { projectType: "brownfield" } : {},
-			...params.ownsInfrastructure !== void 0 ? { ownsInfrastructure: params.ownsInfrastructure } : {},
-			...params.ownsDeployment !== void 0 ? { ownsDeployment: params.ownsDeployment } : {},
-			...params.deploymentNotes !== void 0 ? { deploymentNotes: params.deploymentNotes } : {}
-		})).data;
 		return toolResult(await productRow(client, product));
 	}));
 	server.registerTool("taiga_update_product", {

package/package.json

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

package/src/client.ts

@@ -44,6 +44,8 @@ import type {
   SetupTaskListEntry,
   TenantDocument,
   UptimeReport,
+  CreateFactoryInput,
+  CreateProductInput,
 } from '@taiga/types';
 import { SERVER_VERSION } from './version.js';
 
@@ -844,7 +846,7 @@ export class TaigaClient {
     return this.request<Page<Factory>>('GET', `/factories${qs ? `?${qs}` : ''}`);
   }
 
-  async createFactory(body: { name: string }) {
+  async createFactory(body: CreateFactoryInput) {
     return this.request<One<Factory>>('POST', '/factories', body);
   }
 
@@ -856,14 +858,18 @@ export class TaigaClient {
   // Setting a product up
   // ---------------------------------------------------------------------------
 
-  async createProduct(body: {
-    name: string;
-    factoryId: string;
-    projectType?: 'brownfield' | undefined;
-    ownsInfrastructure?: boolean | null | undefined;
-    ownsDeployment?: boolean | null | undefined;
-    deploymentNotes?: string | undefined;
-  }) {
+  async createProduct(
+    body: Pick<
+      CreateProductInput,
+      | 'name'
+      | 'factoryId'
+      | 'projectType'
+      | 'ownsInfrastructure'
+      | 'ownsDeployment'
+      | 'deploymentNotes'
+      | 'refuseDuplicateName'
+    >
+  ) {
     return this.request<One<Product>>('POST', '/products', body);
   }
 

package/src/server.integration.test.ts

@@ -5790,13 +5790,14 @@ describe('MCP server integration', () => {
       );
 
       // Following the organization is saying nothing, as the web's dialog does.
-      expect(firstBody).toEqual({ name: 'Billing', factoryId: FACTORY_ID });
+      expect(firstBody).toEqual({ name: 'Billing', factoryId: FACTORY_ID, refuseDuplicateName: true });
       expect(sentBody(fetchSpy, 'POST', '/v1/products')).toEqual({
         name: 'Billing',
         factoryId: FACTORY_ID,
         projectType: 'brownfield',
         ownsDeployment: false,
         deploymentNotes: 'Platform team owns the pipelines',
+        refuseDuplicateName: true,
       });
       expect(scratch).toMatchObject({ id: PRODUCT_ID, projectType: 'greenfield' });
       expect(imported).toMatchObject({ projectType: 'brownfield', ownsDeployment: false });
@@ -5889,7 +5890,7 @@ describe('MCP server integration', () => {
         arguments: { productId: PRODUCT_ID, factoryId: OTHER_FACTORY_ID, stopLine: true },
       });
 
-      expect(factoryBody).toEqual({ name: 'Payments' });
+      expect(factoryBody).toEqual({ name: 'Payments', refuseDuplicateName: true });
       expect(created).toEqual({ id: OTHER_FACTORY_ID, name: 'Payments', slug: 'payments', isDefault: false });
       expect(renamed.name).toBe('Payments EU');
       expect(seen).toEqual(preview);
@@ -7810,58 +7811,142 @@ describe('what the fourth agent review found (PRO-2800)', () => {
     expect(runs[0]!['actions']).toEqual([]);
   });
 
-  it('refuses a factory or product name already taken, unless the person wants a second', async () => {
+  it("reads how a run's initiative ended from the run itself, with no backlog read (PRO-2808)", async () => {
+    const base = { productId: PRODUCT_ID, status: 'needs_review', prState: 'open', completedSteps: 3, totalSteps: 3 };
     const { client, fetchSpy } = await bootMcpPair({
-      capabilities: ALL_CAPABILITIES,
+      // No backlog:read: before PRO-2808 these rows said only that nobody checked.
+      capabilities: ['products:read'],
       routes: {
-        'GET /v1/factories': { data: [{ id: FACTORY_ID, name: 'Platform', slug: 'platform' }], nextCursor: null },
-        'POST /v1/factories': { data: { id: 'new', name: 'platform', slug: 'platform-2', isDefault: false } },
+        [`/v1/products/${PRODUCT_ID}/builds`]: {
+          data: [
+            { ...base, id: 'r1', backlogItemId: 'i1', prNumber: 10, initiativeClosed: 'archived' },
+            { ...base, id: 'r2', backlogItemId: 'i2', prNumber: 11, initiativeClosed: 'done' },
+            { ...base, id: 'r3', backlogItemId: 'i3', prNumber: 12, initiativeClosed: null },
+          ],
+          nextCursor: null,
+        },
       },
     });
 
-    const refused = await client.callTool({ name: 'taiga_create_factory', arguments: { name: ' platform ' } });
-    const made = await client.callTool({
-      name: 'taiga_create_factory',
-      arguments: { name: 'platform', allowDuplicateName: true },
-    });
+    const runs = parseToolResult(
+      await client.callTool({ name: 'taiga_list_runs', arguments: { productId: PRODUCT_ID } })
+    ).data as Record<string, unknown>[];
 
-    expect(parseToolResult(refused)).toMatchObject({ error: 'DUPLICATE_NAME', details: { existingId: FACTORY_ID } });
-    expect(made.isError).toBeFalsy();
-    expect(
-      fetchSpy.mock.calls.filter((call: unknown[]) => (call[1] as RequestInit | undefined)?.method === 'POST')
-    ).toHaveLength(1);
+    expect(runs.map((run) => [run['disposition'], run['outcome']])).toEqual([
+      [
+        'abandoned',
+        'Its initiative was archived, so nobody is waiting on this run. PR #10 is still open on the forge.',
+      ],
+      [
+        'abandoned',
+        'Its initiative was marked done, so nobody is waiting on this run. PR #11 is still open on the forge.',
+      ],
+      [runs[2]!['disposition'], expect.not.stringMatching(/not checked|abandoned|nobody/)],
+    ]);
+    expect(runs[2]!['disposition']).not.toBe('abandoned');
+    expect(fetchSpy.mock.calls.some(([url]) => String(url).includes('/v1/backlog/'))).toBe(false);
   });
 
-  it('refuses a product name already taken, unless the person wants a second', async () => {
-    const { client, fetchSpy } = await bootMcpPair({
-      capabilities: ALL_CAPABILITIES,
+  it('reads an archived initiative as archived from an API that does not say it on the run (PRO-2808)', async () => {
+    const base = { productId: PRODUCT_ID, status: 'needs_review', prState: 'open', completedSteps: 3, totalSteps: 3 };
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read', 'backlog:read'],
       routes: {
-        'GET /v1/products': {
-          data: [{ id: PRODUCT_ID, name: 'Web', slug: 'web', factoryId: FACTORY_ID }],
+        [`/v1/products/${PRODUCT_ID}/builds`]: {
+          data: [{ ...base, id: 'r1', backlogItemId: ITEM_ID, prNumber: 10 }],
           nextCursor: null,
         },
-        'POST /v1/products': {
-          data: { id: PRODUCT_ID_2, name: 'web', slug: 'web-2', status: 'active', factoryId: FACTORY_ID, settings: {} },
+        // Archiving keeps the status the initiative had.
+        [`GET /v1/backlog/${ITEM_ID}`]: {
+          data: { id: ITEM_ID, status: 'in_progress', state: 'build', archivedAt: '2026-10-09T10:00:00.000Z' },
         },
       },
     });
 
-    const refused = await client.callTool({
-      name: 'taiga_create_product',
-      arguments: { factoryId: FACTORY_ID, name: 'WEB', start: 'scratch' },
+    const runs = parseToolResult(
+      await client.callTool({ name: 'taiga_list_runs', arguments: { productId: PRODUCT_ID } })
+    ).data as Record<string, unknown>[];
+
+    expect(runs[0]).toMatchObject({
+      disposition: 'abandoned',
+      outcome: expect.stringMatching(/^Its initiative was archived/),
     });
+  });
+
+  it('asks the API to refuse a taken name, and says so naming the one that exists (PRO-2808)', async () => {
+    const reply = (ok: boolean, status: number, body: unknown) => ({
+      ok,
+      status,
+      json: () => Promise.resolve(body),
+      text: () => Promise.resolve(JSON.stringify(body)),
+    });
+    const taken = reply(false, 409, {
+      error: 'CONFLICT',
+      code: 'CONFLICT',
+      message: 'A factory named "Platform" already exists in this organization.',
+      details: {
+        reason: 'duplicate_name',
+        existingId: FACTORY_ID,
+        existingSlug: 'platform',
+        existingName: 'Platform',
+        existingCreatedAt: '2026-10-10T10:00:00.000Z',
+      },
+    });
+    const { client, fetchSpy } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        'POST /v1/factories': (_url: string, init: RequestInit) =>
+          JSON.parse(init.body as string).refuseDuplicateName
+            ? taken
+            : reply(true, 201, { data: { id: 'new', name: 'platform', slug: 'platform-2', isDefault: false } }),
+      },
+    });
+
+    const refused = parseToolResult(
+      await client.callTool({ name: 'taiga_create_factory', arguments: { name: ' platform ' } })
+    );
     const made = await client.callTool({
-      name: 'taiga_create_product',
-      arguments: { factoryId: FACTORY_ID, name: 'web', start: 'scratch', allowDuplicateName: true },
+      name: 'taiga_create_factory',
+      arguments: { name: 'platform', allowDuplicateName: true },
     });
 
-    expect(parseToolResult(refused)).toMatchObject({ error: 'DUPLICATE_NAME', details: { existingId: PRODUCT_ID } });
+    expect(refused).toMatchObject({ error: 'DUPLICATE_NAME', details: { existingId: FACTORY_ID } });
+    expect(refused.message).toBe(
+      `A factory named "Platform" already exists in this organization (${FACTORY_ID}, created ` +
+        "2026-10-10T10:00:00.000Z). It may not be this person's: ask whether they meant that one, want another " +
+        'name, or want a second (allowDuplicateName: true).'
+    );
     expect(made.isError).toBeFalsy();
-    const posts = fetchSpy.mock.calls.filter(
-      (call: unknown[]) =>
-        (call[1] as RequestInit | undefined)?.method === 'POST' && String(call[0]).endsWith('/v1/products')
+    const bodies = fetchSpy.mock.calls
+      .filter((call: unknown[]) => (call[1] as RequestInit | undefined)?.method === 'POST')
+      .map((call: unknown[]) => JSON.parse((call[1] as RequestInit).body as string));
+    expect(bodies.map((body: Record<string, unknown>) => body['refuseDuplicateName'])).toEqual([true, false]);
+    // No list read first: the API's check is the one that holds.
+    expect(fetchSpy.mock.calls.some((call: unknown[]) => String(call[0]).includes('/v1/factories?'))).toBe(false);
+  });
+
+  it('says a product name is taken without naming the one a caller cannot read', async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ALL_CAPABILITIES,
+      routes: {
+        'POST /v1/products': refusal(409, 'CONFLICT', 'A product with this name already exists in this factory.', {
+          reason: 'duplicate_name',
+        }),
+      },
+    });
+
+    const refused = parseToolResult(
+      await client.callTool({
+        name: 'taiga_create_product',
+        arguments: { factoryId: FACTORY_ID, name: 'WEB', start: 'scratch' },
+      })
+    );
+
+    expect(refused).toMatchObject({ error: 'DUPLICATE_NAME', details: {} });
+    expect(refused.message).toBe(
+      'A product with this name already exists in this factory. The caller cannot read it: ask whether they want ' +
+        'another name or a second (allowDuplicateName: true).'
     );
-    expect(posts).toHaveLength(1);
   });
 
   it('bounds the full policy standing and reads one violation whole', async () => {
@@ -8172,36 +8257,6 @@ describe('what the fourth agent review found (PRO-2800)', () => {
     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'],

package/src/tools/builds.ts

@@ -273,9 +273,14 @@ const INITIATIVE_CHECKS = 10;
  * The status of the initiative behind each run still waiting on its pull
  * request (PRO-2800). A reviewing agent read a run of a canceled initiative as
  * "waiting for a person to review and merge" while Action Required called the
- * same review stale. A 404 is 'deleted'. Best effort: an initiative past the
- * cap, one whose read failed, and every one without backlog:read is
- * 'unchecked', which withInitiativeState adds to the row's outcome.
+ * same review stale.
+ *
+ * The run says it itself since PRO-2808 (initiativeClosed: done, canceled,
+ * archived, deleted, or null while live), for every key that can read it.
+ * Against an API from before that, each initiative is read: a 404 is
+ * 'deleted', and an initiative past the cap, one whose read failed, and every
+ * one without backlog:read is 'unchecked', which withInitiativeState adds to
+ * the row's outcome.
  */
 export async function initiativeStates(
   client: TaigaClient,
@@ -286,8 +291,19 @@ export async function initiativeStates(
   const waiting = rows.filter(
     (row) => ['needs_review', 'completed'].includes(String(row['status'])) && row['prMerged'] !== true
   );
+  const told = waiting.filter((row) => 'initiativeClosed' in row);
+  for (const row of told) {
+    if (typeof row['backlogItemId'] === 'string') {
+      states.set(row['backlogItemId'], typeof row['initiativeClosed'] === 'string' ? row['initiativeClosed'] : 'live');
+    }
+  }
   const all = [
-    ...new Set(waiting.map((row) => row['backlogItemId']).filter((id): id is string => typeof id === 'string')),
+    ...new Set(
+      waiting
+        .filter((row) => !('initiativeClosed' in row))
+        .map((row) => row['backlogItemId'])
+        .filter((id): id is string => typeof id === 'string' && !states.has(id))
+    ),
   ];
   // Without backlog:read, or past the cap, a waiting run's initiative is not read: it is marked unchecked so
   // the row does not claim a person is waiting when nobody may be.
@@ -297,7 +313,8 @@ export async function initiativeStates(
     ids.map(async (id) => {
       try {
         const item = (await client.getBacklogItem(id)).data as unknown as Record<string, unknown>;
-        states.set(id, String(item['status'] ?? item['state']));
+        // Archiving keeps the status it had, so it is read apart, as the API reads it (initiativeClosed).
+        states.set(id, item['archivedAt'] ? 'archived' : String(item['status'] ?? item['state']));
       } catch (error) {
         if (error instanceof TaigaApiError && error.status === 404) return void states.set(id, 'deleted');
         if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
@@ -308,7 +325,19 @@ export async function initiativeStates(
   return states;
 }
 
-/** A readable run row that also says when its initiative was canceled or deleted while its pull request waited. */
+/**
+ * How each way an initiative ends reads on a run it left waiting: the same set
+ * Action Required closes a run's review for (PRO-2806). A done one's waiting
+ * run is not the one that landed it: that run is merged and never waiting.
+ */
+const INITIATIVE_ENDED: Record<string, string> = {
+  done: 'was marked done',
+  canceled: 'was canceled',
+  archived: 'was archived',
+  deleted: 'was deleted',
+};
+
+/** A readable run row that also says when its initiative ended while its pull request waited. */
 export function withInitiativeState(
   row: Record<string, unknown>,
   states: Map<string, string>
@@ -320,7 +349,8 @@ export function withInitiativeState(
   if (state === 'unchecked') {
     return { ...row, outcome: `${String(row['outcome'])} Whether its initiative still wants it was not checked.` };
   }
-  if (state !== 'canceled' && state !== 'deleted') return row;
+  const ended = state ? INITIATIVE_ENDED[state] : undefined;
+  if (!ended) return row;
   const pr = typeof row['prNumber'] === 'number' ? `PR #${row['prNumber']}` : 'its pull request';
   const open = row['prState'] === 'open' ? ` ${pr} is still open on the forge.` : '';
   return {
@@ -328,7 +358,7 @@ export function withInitiativeState(
     disposition: 'abandoned',
     // Retry or start over cannot succeed once the initiative is gone.
     actions: [],
-    outcome: `Its initiative was ${state}, so nobody is waiting on this run.${open}`,
+    outcome: `Its initiative ${ended}, so nobody is waiting on this run.${open}`,
   };
 }
 
@@ -485,8 +515,9 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
       description:
         'List coding agent runs, newest first: branch, pull request, step progress, outcome (one sentence), ' +
         'actions and disposition: in_flight, gated (a person owes a review and merge), succeeded (merged), ' +
-        'failed, stopped, rejected (pull request closed unmerged), unmerged, or abandoned (initiative canceled ' +
-        "or deleted). Without productId, every product's runs; active: true keeps running ones. taiga_get_run " +
+        'failed, stopped, rejected (pull request closed unmerged), unmerged, or abandoned (its initiative ended: ' +
+        "done, canceled, archived or deleted). Without productId, every product's runs; active: true keeps " +
+        'running ones. taiga_get_run ' +
         'reads one; carry work on from the initiative (taiga_resume_initiative).',
       inputSchema: z.object({
         productId: productId.optional(),

package/src/tools/setup.ts

@@ -5,7 +5,7 @@ import type { Product } from '@taiga/types';
 import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
 import { OPERATE, OPERATE_SETTING, READ_ONLY, WRITE } from './annotations.js';
 import { isImportedProduct } from './catalogue.js';
-import { isNetworkFailure, runTool, toolError, toolResult } from './errors.js';
+import { runTool, toolError, toolResult } from './errors.js';
 import { setupReadiness } from './readiness.js';
 import { withStop } from './hints.js';
 import { idInput, productId } from './inputs.js';
@@ -68,58 +68,42 @@ type ProductRow = WithoutTenant<Product>;
 /**
  * Refuse a name already taken (PRO-2800): the API appends -2 to the slug and
  * creates a second one, so a retried call or two agents at once left
- * duplicates nobody asked for. allowDuplicateName says the person means it.
+ * duplicates nobody asked for. The API checks it in the create's transaction
+ * (PRO-2808), so names past any page and two creates at once are caught too.
+ * allowDuplicateName says the person means it.
  */
 const allowDuplicateName = z
   .boolean()
   .optional()
   .describe('Create it even when one with the same name exists (default false: refused, naming the existing one)');
 
-/** The same name, as a person would read it: case and surrounding space aside. */
-const sameName = (a: string, b: string) => a.trim().toLowerCase() === b.trim().toLowerCase();
-
-/** Pages read looking for a taken name; past this the create goes ahead. */
-const NAME_PAGES = 5;
-
 /**
- * The first row with this name, across pages. Best effort: a list the API
- * refuses or fails leaves the check out rather than the create.
+ * The API's refusal of a taken name, as the tool's: it names the one that
+ * exists when the caller may read it, and leaves the choice to the person.
+ * Another session may have made it, so "use it" would hand the agent someone
+ * else's work (PRO-2800, review 6). Anything else is not this refusal.
  */
-async function firstNamed<T extends { id: string; name: string; slug?: string; createdAt?: unknown }>(
-  name: string,
-  read: (cursor: string | undefined) => Promise<{ data: T[]; nextCursor: string | null }>
-): Promise<T | null> {
-  let cursor: string | undefined;
-  try {
-    for (let pageIndex = 0; pageIndex < NAME_PAGES; pageIndex += 1) {
-      const result = await read(cursor);
-      const same = result.data.find((row) => sameName(row.name, name));
-      if (same) return same;
-      if (!result.nextCursor) return null;
-      cursor = result.nextCursor;
-    }
-  } catch (error) {
-    if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
+function duplicateName(kind: 'factory' | 'product', error: unknown, where: string) {
+  if (!(error instanceof TaigaApiError) || error.status !== 409 || error.details?.['reason'] !== 'duplicate_name') {
+    return null;
   }
-  return null;
-}
-
-/**
- * The refusal names the one that exists and leaves the choice to the person: another session may have made it, so
- * "use it" would hand the agent someone else's work (PRO-2800, review 6).
- */
-function duplicateName(
-  kind: 'factory' | 'product',
-  existing: { id: string; name: string; slug?: string; createdAt?: unknown },
-  where: string
-) {
-  const made = typeof existing.createdAt === 'string' ? `, created ${existing.createdAt}` : '';
-  return toolError(
-    'DUPLICATE_NAME',
-    `A ${kind} named "${existing.name}" already exists ${where} (${existing.id}${made}). It may not be this ` +
-      "person's: ask whether they meant that one, want another name, or want a second (allowDuplicateName: true).",
-    { existingId: existing.id, ...(existing.slug ? { existingSlug: existing.slug } : {}) }
-  );
+  const said = (key: string) => (typeof error.details?.[key] === 'string' ? (error.details[key] as string) : undefined);
+  const [existingId, existingSlug, name, createdAt] = [
+    said('existingId'),
+    said('existingSlug'),
+    said('existingName'),
+    said('existingCreatedAt'),
+  ];
+  const which = name ? `A ${kind} named "${name}"` : `A ${kind} with this name`;
+  const ids = existingId ? ` (${existingId}${createdAt ? `, created ${createdAt}` : ''})` : '';
+  // Without the holder's id the caller cannot read it, so "that one" is not a choice they have.
+  const choices = existingId
+    ? "It may not be this person's: ask whether they meant that one, want another name, or want a second"
+    : 'The caller cannot read it: ask whether they want another name or a second';
+  return toolError('DUPLICATE_NAME', `${which} already exists ${where}${ids}. ${choices} (allowDuplicateName: true).`, {
+    ...(existingId ? { existingId } : {}),
+    ...(existingSlug ? { existingSlug } : {}),
+  });
 }
 
 /** A product row the model can act on: how it started, and while in setup what it still needs. */
@@ -186,11 +170,17 @@ export function registerSetupTools(server: McpServer, client: TaigaClient) {
       },
       (params) =>
         runTool(async () => {
-          if (!params.allowDuplicateName) {
-            const same = await firstNamed(params.name, async (cursor) => client.listFactories({ limit: 100, cursor }));
-            if (same) return duplicateName('factory', same, 'in this organization');
+          try {
+            const made = await client.createFactory({
+              name: params.name,
+              refuseDuplicateName: !params.allowDuplicateName,
+            });
+            return toolResult(pickFields([made.data], FACTORY_FIELDS)[0]);
+          } catch (error) {
+            const refused = duplicateName('factory', error, 'in this organization');
+            if (refused) return refused;
+            throw error;
           }
-          return toolResult(pickFields([(await client.createFactory({ name: params.name })).data], FACTORY_FIELDS)[0]);
         })
     );
 
@@ -308,23 +298,25 @@ export function registerSetupTools(server: McpServer, client: TaigaClient) {
       runTool(async () => {
         const contradiction = notesWithNothingToDescribe(params);
         if (contradiction) return contradiction;
-        if (!params.allowDuplicateName) {
-          // Within the factory it goes into: the same name in another factory is a different product.
-          const same = await firstNamed(params.name, async (cursor) =>
-            client.listProducts({ factoryId: params.factoryId, limit: 100, cursor })
-          );
-          if (same) return duplicateName('product', same, 'in this factory');
+        let product: ProductRow;
+        try {
+          product = (
+            await client.createProduct({
+              name: params.name,
+              factoryId: params.factoryId,
+              ...(params.start === 'import' ? { projectType: 'brownfield' as const } : {}),
+              ...(params.ownsInfrastructure !== undefined ? { ownsInfrastructure: params.ownsInfrastructure } : {}),
+              ...(params.ownsDeployment !== undefined ? { ownsDeployment: params.ownsDeployment } : {}),
+              ...(params.deploymentNotes !== undefined ? { deploymentNotes: params.deploymentNotes } : {}),
+              // Within the factory it goes into: the same name in another factory is a different product.
+              refuseDuplicateName: !params.allowDuplicateName,
+            })
+          ).data;
+        } catch (error) {
+          const refused = duplicateName('product', error, 'in this factory');
+          if (refused) return refused;
+          throw error;
         }
-        const product = (
-          await client.createProduct({
-            name: params.name,
-            factoryId: params.factoryId,
-            ...(params.start === 'import' ? { projectType: 'brownfield' as const } : {}),
-            ...(params.ownsInfrastructure !== undefined ? { ownsInfrastructure: params.ownsInfrastructure } : {}),
-            ...(params.ownsDeployment !== undefined ? { ownsDeployment: params.ownsDeployment } : {}),
-            ...(params.deploymentNotes !== undefined ? { deploymentNotes: params.deploymentNotes } : {}),
-          })
-        ).data;
         return toolResult(await productRow(client, product));
       })
   );