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

package/dist/index.js

@@ -584,7 +584,7 @@ const OPERATE_SETTING = {
 * "Invalid UUID" alone sends a model that passed a name to guess again.
 */
 function idInput(what, from) {
-	return z.string().uuid({ message: `A ${what} ID is a UUID, not a name: ${from}` }).describe(`${what[0].toUpperCase()}${what.slice(1)} ID -- ${from}`);
+	return z.string().uuid({ message: `${/^[aeiou]/i.test(what) ? "An" : "A"} ${what} ID is a UUID, not a name: ${from}` }).describe(`${what[0].toUpperCase()}${what.slice(1)} ID -- ${from}`);
 }
 const productId = idInput("product", "taiga_list_products (query finds one by name), or taiga_get_product with a git remote URL, gives it");
 /** The page inputs every list tool takes; `nextCursor` of one page is the `cursor` of the next. */
@@ -2379,7 +2379,7 @@ function inProductWords(value) {
 }
 /** The API's 404 sentence in the product's words: "Backlog item not found" is an initiative not found. */
 function inProductWording(said) {
-	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").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. */
 function toolResult(value) {
@@ -2460,8 +2460,8 @@ async function runTool(handler) {
 	} catch (error) {
 		if (error instanceof TaigaApiError) {
 			const code = error.code ?? CODE_BY_STATUS[error.status] ?? "API_ERROR";
-			const said = error.apiMessage ?? `Taiga API answered ${error.status}.`;
-			return toolError(code, error.status === 404 ? withNotFoundHint(inProductWording(said)) : said, error.details);
+			const worded = inProductWording(error.apiMessage ?? `Taiga API answered ${error.status}.`);
+			return toolError(code, error.status === 404 ? withNotFoundHint(worded) : worded, error.details);
 		}
 		if (isNetworkFailure(error)) return toolError("NETWORK_ERROR", `Could not reach the Taiga API: ${networkFailureDetail(error)}. Check TAIGA_API_URL.`);
 		throw error;
@@ -3088,7 +3088,7 @@ async function resolveProductRef(client, ref, accepted, usage) {
 		return { product: (await client.getProduct(ref.productId)).data };
 	} catch (error) {
 		if (!isMissOrRefusal(error)) throw error;
-		return refusal(apiFailureCode(error), `No product with that ID the key can see (${apiFailureText(error)}); taiga_list_products shows the ones it can.`);
+		return refusal(apiFailureCode(error), error instanceof TaigaApiError && error.status === 404 ? "No product with that ID the key can see; taiga_list_products shows the ones it can." : `No product with that ID the key can see (${apiFailureText(error)}); taiga_list_products shows the ones it can.`);
 	}
 	if (ref.slug) {
 		const [product] = (await client.listProducts({
@@ -3758,6 +3758,33 @@ function withInitiativeState(row, states) {
 		outcome: `Its initiative was ${state}, so nobody is waiting on this run.${open}`
 	};
 }
+/** 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.
+*/
+function verificationNote(steps) {
+	const checked = steps.filter((step) => Array.isArray(step["verification"]) && step["verification"].length > 0);
+	if (checked.length < 2) return null;
+	const failedOn = (step) => step["verification"].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)));
+	});
+	if (!prose && checked.length < 3) return null;
+	const reasons = [...new Set(checked.flatMap((step) => step["verification"].filter((check) => check.status === "failed" && always.includes(String(check.check))).map((check) => check.reason).filter((reason) => 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. */
 const readableRow = (run) => readableRun(run, { row: true });
 /** How many products the org-wide list names; past this a row keeps its productId only. */
@@ -3860,14 +3887,18 @@ function registerBuildTools(server, client) {
 		const stop = where ? { stoppedIn: where } : {};
 		const states = await initiativeStates(client, [runRow]);
 		const readable = withInitiativeState(readableRun(runRow), states);
+		const note = verificationNote(rows);
+		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)
@@ -4272,16 +4303,18 @@ function registerBacklogTools(server, client) {
 function registerBacklogReads(server, client) {
 	server.registerTool("taiga_list_initiatives", {
 		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.",
+		description: "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.string().trim().min(1).max(200).optional().describe("Part of the title, any case: only the items that contain it"),
 			status: z.enum([
+				"open",
+				"all",
 				"backlog",
 				"in_progress",
 				"done",
 				"canceled"
-			]).optional().describe("Only items with this status; in_progress covers everything between backlog and done"),
+			]).optional().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",
@@ -4300,32 +4333,25 @@ function registerBacklogReads(server, client) {
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const { query, state, ...filters } = params;
-		if (state !== void 0) {
-			if (params.cursor !== void 0) 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: 100,
-				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 === void 0) {
-			const result = await client.listBacklogItems(params.productId, filters);
+		const { query, state, status = state === void 0 ? "open" : "all", ...filters } = params;
+		const apiFilters = {
+			...filters,
+			status: status === "open" || status === "all" ? void 0 : status
+		};
+		const open = status === "open";
+		if (query === void 0 && state === void 0 && !open) {
+			const result = await client.listBacklogItems(params.productId, apiFilters);
 			return toolResult(page(situatedRows(result.data), result.nextCursor));
 		}
-		if (params.cursor !== void 0) return toolError("VALIDATION_ERROR", SEARCH_WITH_CURSOR);
+		if (params.cursor !== void 0) 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,
+			...apiFilters,
 			limit: 100,
 			cursor
-		}), query, (row) => [row.title], params.limit ?? 25);
+		}), query ?? "", (row) => [row.title], params.limit ?? 25, (row) => (state === void 0 || 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." } : {}
 		});
 	}));
 	server.registerTool("taiga_get_initiative", {
@@ -4564,6 +4590,44 @@ const FINDING_ROW_FIELDS = [
 	"ignoreReason",
 	"ignoreExpiresAt"
 ];
+/**
+* Whether taiga_fix_finding would take a finding, said on the row (PRO-2800): three reviews found a dependency
+* marked remediableBy coding_agent with no fixed version, which the API refuses to fix. The API's own refusals,
+* read off the row; remediableBy stays as the sweep recorded it.
+*/
+function withFixability(row) {
+	if ((row["kind"] === "vulnerable_dependency" || row["kind"] === "outdated_dependency") && !row["recommendedVersion"] && row["remediableBy"] === "coding_agent") return {
+		...row,
+		fixable: false,
+		fixNote: "No fixed version is known yet: taiga_fix_finding refuses it until one is published."
+	};
+	return row;
+}
+/** The parts of an advisory record an agent reads; the rest (every affected range, every reference) is full: true. */
+const ADVISORY_KEPT = [
+	"id",
+	"aliases",
+	"summary",
+	"details",
+	"severity",
+	"published"
+];
+const ADVISORY_TEXT_LIMIT = 1500;
+function leanAdvisory(data) {
+	if (typeof data !== "object" || data === null || !("affected" in data || "references" in data)) return data;
+	const record = data;
+	const kept = Object.fromEntries(ADVISORY_KEPT.filter((key) => key in record).map((key) => [key, record[key]]));
+	const details = kept["details"];
+	if (typeof details === "string" && details.length > ADVISORY_TEXT_LIMIT) kept["details"] = `${details.slice(0, ADVISORY_TEXT_LIMIT)}... [cut at ${ADVISORY_TEXT_LIMIT} of ${details.length} characters; full: true reads it whole]`;
+	const references = Array.isArray(record["references"]) ? record["references"] : [];
+	return {
+		...kept,
+		...references.length > 0 ? {
+			references: references.slice(0, 3),
+			...references.length > 3 ? { referencesNote: `3 of ${references.length}; full: true has every one.` } : {}
+		} : {}
+	};
+}
 /** A sweep as the record of when the product was last checked, and whether that check held. */
 const SWEEP_FIELDS = [
 	"id",
@@ -4662,17 +4726,24 @@ function registerMaintenanceTools(server, client) {
 				sweep: null,
 				sweepNote: "The sweep overview could not be read: an empty list here is not an all-clear."
 			} : sweep ? { sweep } : {},
-			...page(pickFields(result.data, FINDING_ROW_FIELDS), result.nextCursor),
+			...page(pickFields(result.data, FINDING_ROW_FIELDS).map(withFixability), result.nextCursor),
 			...typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {}
 		});
 	}));
 	server.registerTool("taiga_get_finding", {
 		title: "Get a maintenance finding",
-		description: "Read one maintenance finding in full: exploit likelihood (EPSS, known-exploited list), advisory and fixed version, code location, breached policy controls, why it ranks where it does, history (reintroduced, previously resolved) and the remediation under way. A secret's value is never stored, only the rule and location.",
-		inputSchema: z.object({ findingId }),
+		description: "Read one maintenance finding: exploit likelihood (EPSS, known-exploited list), the advisory summarized (full: true for its whole record: every affected range and reference) and fixed version, code location, breached policy controls, why it ranks where it does, history (reintroduced, previously resolved) and the remediation under way. fixable: false with fixNote says taiga_fix_finding would refuse it. A secret's value is never stored, only the rule and location.",
+		inputSchema: z.object({
+			findingId,
+			full: z.boolean().optional().describe("Carry the advisory's whole record: every affected range and reference (default false)")
+		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const { runId, ...finding } = (await client.getFinding(params.findingId)).data;
+		const { runId, ...raw } = (await client.getFinding(params.findingId)).data;
+		const finding = withFixability(params.full ? raw : {
+			...raw,
+			data: leanAdvisory(raw["data"])
+		});
 		return toolResult(runId === void 0 ? finding : {
 			sweepId: runId,
 			...finding
@@ -5011,7 +5082,7 @@ async function documentsPart(client, product, depth) {
 		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) {
 	return (await client.listTenantDocuments({ limit: 100 })).data.filter((row) => POLICY_TYPES.includes(String(row["type"])) && row["isDraft"] === false).map((row) => ({
 		type: row["type"],
@@ -5183,7 +5254,7 @@ function registerContextTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
 	server.registerTool("taiga_get_product_context", {
 		title: "Get product context",
-		description: `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 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 / 1e3}k characters each, full returns all.`,
+		description: `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 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 / 1e3}k characters each, full returns all.`,
 		inputSchema: z.object({
 			productId: productId.optional(),
 			slug: slug.optional(),
@@ -5289,8 +5360,12 @@ function itemRow(row, now, full) {
 	const { snoozedUntil, resolvedAt, ...rest } = pickFields([row], ITEM_FIELDS)[0];
 	const metadata = row["metadata"] ?? {};
 	const created = typeof row["createdAt"] === "string" ? Date.parse(row["createdAt"]) : NaN;
+	const { summary, ...lean } = rest;
 	return {
-		...rest,
+		...row["kind"] === "review_pr" && !full ? lean : {
+			...lean,
+			summary
+		},
 		...snoozedUntil ? { snoozedUntil } : {},
 		...resolvedAt ? { resolvedAt } : {},
 		...typeof metadata["prUrl"] === "string" ? { prUrl: metadata["prUrl"] } : {},
@@ -5298,7 +5373,10 @@ function itemRow(row, now, full) {
 		...full ? { metadata: row["metadata"] } : {}
 	};
 }
-/** What is open, counted by product and kind: the answer to "what needs attention" without reading every row. */
+/**
+* What is open, counted by product and kind: the answer to "what needs attention" without reading every row. An item
+* that no longer stands is counted under stale, not open or byKind, so nobody subtracts by hand (PRO-2800).
+*/
 function summaryOf(rows, stale) {
 	const byProduct = /* @__PURE__ */ new Map();
 	for (const row of rows) {
@@ -5313,9 +5391,11 @@ function summaryOf(rows, stale) {
 			open: 0,
 			byKind: {}
 		});
-		entry.open += 1;
-		entry.byKind[String(row["kind"])] = (entry.byKind[String(row["kind"])] ?? 0) + 1;
 		if (stale.has(String(row["id"]))) entry.stale = (entry.stale ?? 0) + 1;
+		else {
+			entry.open += 1;
+			entry.byKind[String(row["kind"])] = (entry.byKind[String(row["kind"])] ?? 0) + 1;
+		}
 		byProduct.set(key, entry);
 	}
 	return [...byProduct.values()].sort((a, b) => b.open - a.open);
@@ -5350,11 +5430,42 @@ async function staleReviews(client, rows) {
 			unchecked += 1;
 		}
 	}));
+	unchecked += await staleBacklogReviews(client, rows, out);
 	return {
 		stale: out,
 		unchecked
 	};
 }
+/**
+* "Review Initiatives" items whose product has no open initiative left (PRO-2800): two reviews found one
+* waiting 15 days on a product whose initiatives had all moved on, with nothing an agent could act on. Best effort,
+* a handful of products; returns how many could not be checked.
+*/
+async function staleBacklogReviews(client, rows, out) {
+	const asks = [...new Map(rows.filter((row) => row["kind"] === "review_backlog" && typeof row["productId"] === "string").map((row) => [String(row["id"]), row])).values()];
+	if (asks.length === 0) return 0;
+	if (!client.hasCapability("backlog:read")) return asks.length;
+	const checked = [...new Set(asks.map((row) => String(row["productId"])))].slice(0, STALE_CHECKS);
+	let unchecked = asks.filter((row) => !checked.includes(String(row["productId"]))).length;
+	const empty = /* @__PURE__ */ new Set();
+	await Promise.all(checked.map(async (productId) => {
+		try {
+			const [waiting, started] = await Promise.all([client.listBacklogItems(productId, {
+				status: "backlog",
+				limit: 1
+			}), client.listBacklogItems(productId, {
+				status: "in_progress",
+				limit: 1
+			})]);
+			if (waiting.data.length === 0 && started.data.length === 0) empty.add(productId);
+		} catch (error) {
+			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
+			unchecked += asks.filter((row) => row["productId"] === productId).length;
+		}
+	}));
+	for (const row of asks) if (empty.has(String(row["productId"]))) out.set(String(row["id"]), "no initiative is open now: the ones it asked about are all done or canceled");
+	return unchecked;
+}
 /** Pages read for the summary; past this it says it counted only those. */
 const SUMMARY_PAGE = 100;
 const SETUP_TASK_FIELDS = [
@@ -5480,7 +5591,7 @@ function registerInboxTools(server, client) {
 			}), result.nextCursor),
 			...totalOf(result),
 			...hidden > 0 ? { snoozedHidden: hidden } : {},
-			...checked.unchecked > 0 ? { staleNote: `${checked.unchecked} pull request review${checked.unchecked === 1 ? " was" : "s were"} not checked for staleness (past the cap, or the read was refused).` } : {}
+			...checked.unchecked > 0 ? { staleNote: `${checked.unchecked} review${checked.unchecked === 1 ? " was" : "s were"} not checked for staleness (past the cap, or the read was refused).` } : {}
 		});
 	}));
 	server.registerTool("taiga_list_setup_tasks", {
@@ -20767,6 +20878,20 @@ function interleave(lists) {
 	for (let index = 0; index < longest; index++) for (const list of lists) if (index < list.length) out.push(list[index]);
 	return out;
 }
+/**
+* A product in setup says what it still needs after a repository write, as create_product and get_product do
+* (PRO-2800): a reviewer had to read the product again to learn that the import came next. Best effort: the write
+* is done, so a failed read leaves readiness out rather than failing it.
+*/
+async function readinessAfter(client, productId) {
+	try {
+		const readiness = await setupReadiness(client, (await client.getProduct(productId)).data);
+		return readiness ? { readiness } : {};
+	} catch (error) {
+		if (error instanceof TaigaApiError || isNetworkFailure(error)) return {};
+		throw error;
+	}
+}
 function registerRepositoryTools(server, client) {
 	if (client.hasCapability("products:read")) {
 		server.registerTool("taiga_list_product_repositories", {
@@ -20854,10 +20979,13 @@ function registerRepositoryTools(server, client) {
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		return toolResult(pickFields([(await client.linkRepository(params.productId, {
-			githubRepositoryId: params.githubRepositoryId,
-			...params.replacesRepositoryId ? { replacesRepositoryId: params.replacesRepositoryId } : {}
-		})).data], LINK_FIELDS)[0]);
+		return toolResult({
+			...pickFields([(await client.linkRepository(params.productId, {
+				githubRepositoryId: params.githubRepositoryId,
+				...params.replacesRepositoryId ? { replacesRepositoryId: params.replacesRepositoryId } : {}
+			})).data], LINK_FIELDS)[0],
+			...await readinessAfter(client, params.productId)
+		});
 	}));
 	server.registerTool("taiga_set_repository_branch", {
 		title: "Choose the branch Taiga works on",
@@ -20877,7 +21005,8 @@ function registerRepositoryTools(server, client) {
 		})).data;
 		return toolResult({
 			...pickFields([updated], LINK_FIELDS)[0],
-			baseBranchProtection: updated.baseBranchProtection ?? null
+			baseBranchProtection: updated.baseBranchProtection ?? null,
+			...await readinessAfter(client, params.productId)
 		});
 	}));
 	server.registerTool("taiga_unlink_repository", {
@@ -21082,8 +21211,13 @@ async function firstNamed(name, read) {
 	}
 	return null;
 }
-function duplicateName(kind, existing) {
-	return toolError("DUPLICATE_NAME", `A ${kind} named "${existing.name}" already exists (${existing.id}). Use it, choose another name, or pass allowDuplicateName: true if the person wants a second one.`, {
+/**
+* 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 } : {}
 	});
@@ -21131,7 +21265,7 @@ function registerSetupTools(server, client) {
 					limit: 100,
 					cursor
 				}));
-				if (same) return duplicateName("factory", same);
+				if (same) return duplicateName("factory", same, "in this organization");
 			}
 			return toolResult(pickFields([(await client.createFactory({ name: params.name })).data], FACTORY_FIELDS)[0]);
 		}));
@@ -21185,7 +21319,7 @@ function registerSetupTools(server, client) {
 	if (!client.hasCapability("products:write")) return;
 	server.registerTool("taiga_create_product", {
 		title: "Create a product",
-		description: "Create a product in a factory, as New product does, and return it. Choose now how it starts; it cannot change later: scratch (projectType greenfield), where Discovery is a conversation in the web that writes the specification, or import (brownfield), where Taiga drafts the documents from a repository: taiga_link_repository (owners and admins only), then taiga_start_import. Infrastructure code and CI/CD pipelines follow the organization unless set here; when one is off, deploymentNotes says how that half is done today. Add source material first with taiga_add_knowledge (productId): Discovery writes from it.",
+		description: "Create a product in a factory and return it with readiness (what it needs next). start cannot change later. import (brownfield): Taiga drafts the documents from existing code; link it with taiga_link_repository (owners and admins only), then taiga_start_import. scratch (greenfield): Discovery is a conversation in the web that writes the specification. Infrastructure code and CI/CD pipelines follow the organization unless set here; when one is off, deploymentNotes says how that half is done today. Add source material first with taiga_add_knowledge (productId): Discovery writes from it.",
 		inputSchema: z.object({
 			factoryId,
 			name: z.string().trim().min(1).max(255).describe("The product name"),
@@ -21200,10 +21334,11 @@ function registerSetupTools(server, client) {
 		if (contradiction) return contradiction;
 		if (!params.allowDuplicateName) {
 			const same = await firstNamed(params.name, async (cursor) => client.listProducts({
+				factoryId: params.factoryId,
 				limit: 100,
 				cursor
 			}));
-			if (same) return duplicateName("product", same);
+			if (same) return duplicateName("product", same, "in this factory");
 		}
 		const product = (await client.createProduct({
 			name: params.name,
@@ -21632,14 +21767,14 @@ function registerWaitTools(server, client, options) {
 * model learns the tool's real shape. Applied here, once, so no tool can be
 * registered without it.
 */
-function withStrictInputs(server, registered) {
+function withStrictInputs(server, client, registered) {
 	const register = server.registerTool.bind(server);
 	server.registerTool = ((name, config, callback) => {
 		registered.set(name, config.annotations);
 		const schema = config.inputSchema;
 		if (schema !== void 0 && !(schema instanceof z.ZodObject)) throw new Error(`Tool ${name}: inputSchema must be a z.object() so unknown arguments can be refused`);
 		const handler = callback;
-		const withHint = (args, ctx) => notFoundHints.run(notFoundHint(name, args), () => handler(args, ctx));
+		const withHint = async (args, ctx) => withIdKind(client, args, await notFoundHints.run(notFoundHint(name, args), () => handler(args, ctx)));
 		const described = {
 			...config,
 			description: `${writeNotice(name, config.annotations)}${config.description ?? ""}`,
@@ -21653,6 +21788,42 @@ function withStrictInputs(server, registered) {
 	return server;
 }
 /**
+* A product the API does not know may be a factory's ID passed as one (PRO-2800): the hint can only say a product
+* ID is wanted, so on that miss alone one read names what the ID is.
+*/
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function withIdKind(client, args, result) {
+	const productId = typeof args === "object" && args !== null ? args["productId"] : null;
+	const answer = result;
+	const first = answer?.isError ? answer.content?.[0] : void 0;
+	if (typeof productId !== "string" || first?.type !== "text") return result;
+	let body;
+	try {
+		body = JSON.parse(first.text);
+	} catch {
+		return result;
+	}
+	if (body.error !== "NOT_FOUND" || !/\b(product|project) not found|No product with that ID/i.test(String(body.message))) return result;
+	if (!UUID.test(productId) || !client.hasCapability("factories:read")) return result;
+	try {
+		const factory = (await client.getFactory(productId)).data;
+		const message = `${String(body.message)} That ID is the factory "${factory.name}", not a product: taiga_list_products with factoryId lists its products.`;
+		return {
+			...answer,
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					...body,
+					message
+				})
+			}, ...answer.content.slice(1)]
+		};
+	} catch (error) {
+		if (error instanceof TaigaApiError || isNetworkFailure(error)) return result;
+		throw error;
+	}
+}
+/**
 * The entry points, loaded with their descriptions at session start
 * (PRO-2800). Claude Code defers every other MCP tool behind tool search and
 * shows the model only its name until it searches, so an agent meeting Taiga
@@ -21712,7 +21883,7 @@ const PAID_WORK = /* @__PURE__ */ new Set([
 */
 function registerAllTools(server, client, options = {}) {
 	const registered = /* @__PURE__ */ new Map();
-	withStrictInputs(server, registered);
+	withStrictInputs(server, client, registered);
 	registerProductTools(server, client);
 	registerDocumentTools(server, client);
 	registerBacklogTools(server, client);
@@ -21783,7 +21954,7 @@ const SERVER_INSTRUCTIONS = [
 	"**Which read.** Where a product stands: taiga_get_product_context (by git remote URL, slug or ID). What waits on",
 	"people: taiga_list_action_required. A policy: taiga_get_document (sections: [] for the outline, or a control id",
 	"such as SEC-5.1). Findings: taiga_list_findings. One initiative or run: taiga_get_initiative, taiga_get_run.",
-	"This key's role and tools: taiga_whoami.",
+	"This key's role and which tools write: taiga_whoami.",
 	"",
 	"**Words.** An initiative is a unit of work; its board columns are backlog, todo, queue, plan, build, done, canceled. The",
 	"line is the product's queue, worked one initiative at a time through plan and build. A run is one attempt by the",
@@ -21795,8 +21966,9 @@ const SERVER_INSTRUCTIONS = [
 	"(derived from the code). outcome, situation and nextStep are one-sentence summaries of their record.",
 	"",
 	"**Writing.** A tool that writes opens with \"Writes.\", \"Ask first (paid agent work).\" or \"Ask first (others see",
-	"it).\"; before an ask-first tool, tell the person what you will do and wait for their yes. A taken factory or",
-	"product name is refused unless allowDuplicateName.",
+	"it).\"; before an ask-first tool, tell the person what you will do and wait for their yes. Others share this",
+	"organization: a taken factory name (or product name in its factory) is refused unless allowDuplicateName, and",
+	"the one that exists may not be this person's.",
 	"",
 	"**Only in the web:** connecting GitHub, members and roles, the Discovery conversation of a product started from",
 	"scratch, stamping checks, starting a run over, and deleting factories and products."

package/package.json

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