@taiga-ai/mcp-server 0.24.0-rc.462 → 0.25.0-dev.465

package/dist/index.js

@@ -202,13 +202,6 @@ var TaigaClient = class {
 	async publishTenantDocument(type) {
 		return this.request("POST", `/tenants/current/documents/${seg(type)}/publish`);
 	}
-	async listFactoryDocuments(factoryId, opts) {
-		const params = new URLSearchParams();
-		if (opts?.limit) params.set("limit", String(opts.limit));
-		if (opts?.cursor) params.set("cursor", opts.cursor);
-		const qs = params.toString();
-		return this.request("GET", `/factories/${seg(factoryId)}/documents${qs ? `?${qs}` : ""}`);
-	}
 	async getFactoryDocument(factoryId, type) {
 		return this.request("GET", `/factories/${seg(factoryId)}/documents/${seg(type)}`);
 	}
@@ -2251,7 +2244,7 @@ function setupNextStep(product) {
 	if (isImportedProduct(product)) switch (importStatusOf(product)) {
 		case "analyzing":
 		case "generating_docs": return "The import is running and derives the documents from the code (taiga_wait_for_job follows its job). Then review them, and taiga_finish_discovery opens the product.";
-		case "complete": return "The import is done: review the reality documents (taiga_list_product_documents), then taiga_finish_discovery opens the product.";
+		case "complete": return "The import is done: review the reality documents (taiga_get_product_document without type), then taiga_finish_discovery opens the product.";
 		case "failed":
 		case "cancelled": return "The last import did not finish: taiga_start_import runs it again.";
 		default: return "Link its repository if it has none (taiga_list_linkable_repositories, taiga_link_repository), then taiga_start_import: the import derives the documents from the code and runs by itself.";
@@ -2735,7 +2728,7 @@ function sectionReadResult(doc, asked, label, options = {}) {
 	const found = Object.keys(controls).length > 0 ? { controls } : {};
 	const asControl = options.controlIds ? void 0 : unknownSections.find((id) => isControlId(id));
 	const policy = asControl ? policyOfControl(asControl) : void 0;
-	const controlNote = asControl ? { note: policy ? `${asControl} is a control of ${policy}: read it with taiga_get_document (type: ${policy}, sections: ["${asControl}"]).` : `${asControl} looks like a policy control id, which only a policy resolves: taiga_list_documents lists them.` } : {};
+	const controlNote = asControl ? { note: policy ? `${asControl} is a control of ${policy}: read it with taiga_get_document (type: ${policy}, sections: ["${asControl}"]).` : `${asControl} looks like a policy control id, which only a policy resolves: taiga_get_document without type lists them.` } : {};
 	if (known.length === 0) {
 		const { data: _data, ...meta } = cut.doc;
 		return toolResult({
@@ -2826,8 +2819,8 @@ function nextStepFor(state) {
 			case "running": return "The import is running and derives the documents from the code; taiga_wait_for_job follows it.";
 			case "failed": return "The last import did not finish: taiga_start_import runs it again.";
 			case "complete":
-				if (state.missing && state.missing.length > 0) return `The import finished but ${named(state.missing)} ${state.missing.length === 1 ? "is" : "are"} not published: taiga_list_product_documents shows them, taiga_publish_product_document publishes a draft.`;
-				return `The import is done: review the reality documents (taiga_list_product_documents), then ${finish}`;
+				if (state.missing && state.missing.length > 0) return `The import finished but ${named(state.missing)} ${state.missing.length === 1 ? "is" : "are"} not published: taiga_get_product_document without type shows them, taiga_publish_product_document publishes a draft.`;
+				return `The import is done: review the reality documents (taiga_get_product_document without type), then ${finish}`;
 			default: return "taiga_start_import derives the documents from the code and runs by itself (paid agent work: ask first).";
 		}
 	}
@@ -3120,7 +3113,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), 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.`);
+		return refusal(apiFailureCode(error), error instanceof TaigaApiError && error.status === 404 ? "No product with that ID the key can see. taiga_list_products (query finds one by name) shows the ones it can; a slug or git remote URL names one too." : `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({
@@ -3242,38 +3235,34 @@ function registerProductTools(server, client) {
 				readiness
 			} : resolved.product);
 		}));
-		server.registerTool("taiga_list_product_documents", {
-			title: "List product documents",
-			description: `List a product's documents on both timelines (type, name, version, draft state, review and update times); defaultOrigin is the product's own. ${ORIGIN_MEANING.plan} ${ORIGIN_MEANING.reality} An empty side says why; an unlisted side is null with a note. taiga_get_product_document reads one.`,
-			inputSchema: z.object({ productId }),
-			annotations: READ_ONLY
-		}, (params) => runTool(async () => {
-			const { unlistable: _unlistable, ...timelines } = await documentTimelines(client, params.productId);
-			return toolResult(timelines);
-		}));
 		server.registerTool("taiga_get_product_document", {
 			title: "Get product document",
-			description: "Read one product document from one timeline: plan (specification, architecture, threat_model, technology_decisions) says what to build; reality says what the code does, so read it before changing code. Omit origin for the product's own timeline. sections: [] returns the outline (ids, sizes); then name the sections you need (unknownSections names missing ids). A miss says which documents exist.",
+			description: "Read one product document from one timeline, or without type list both timelines (type, version, draft and review state; defaultOrigin is the product's own; an empty side says why). plan (specification, architecture, threat_model, technology_decisions) says what to build; reality says what the code does, so read it before changing code. Omit origin for the product's own timeline. sections: [] returns the outline (ids, sizes); then name the sections you need (unknownSections names missing ids). A miss says which documents exist.",
 			inputSchema: z.object({
 				productId,
-				type: z.enum(PRODUCT_DOCUMENT_TYPES).describe("Document type -- taiga_list_product_documents shows which ones the product has"),
+				type: z.enum(PRODUCT_DOCUMENT_TYPES).optional().describe("Document type; omit to list what the product has on both timelines"),
 				origin: originInput,
 				sections: sectionsInput
 			}),
 			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
+			if (params.type === void 0) {
+				if (params.sections || params.origin) return toolError("VALIDATION_ERROR", "Name the document (type) to read one timeline or its sections.");
+				const { unlistable: _unlistable, ...timelines } = await documentTimelines(client, params.productId);
+				return toolResult(timelines);
+			}
+			const type = params.type;
 			let product;
 			if (!params.origin) product = (await client.getProduct(params.productId)).data;
-			const origin = params.origin ?? defaultOriginFor(product, params.type);
+			const origin = params.origin ?? defaultOriginFor(product, type);
 			try {
-				const doc = stripProvenance((await client.getProductDocument(params.productId, params.type, origin)).data);
+				const doc = stripProvenance((await client.getProductDocument(params.productId, type, origin)).data);
 				if (!params.sections) return toolResult(doc);
-				return sectionReadResult(doc, params.sections, `${origin} ${params.type}`);
+				return sectionReadResult(doc, params.sections, `${origin} ${type}`);
 			} catch (error) {
 				if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
 				product ??= (await client.getProduct(params.productId)).data;
-				const timelines = await documentTimelines(client, params.productId, product);
-				return toolError("NOT_FOUND", describeMiss(params.type, origin, timelines, product));
+				return toolError("NOT_FOUND", describeMiss(type, origin, await documentTimelines(client, params.productId, product), product));
 			}
 		}));
 	}
@@ -3319,7 +3308,7 @@ function sectionIdFrom(readTool) {
 	return z.string().min(1).describe(`Section id -- the keys of \`data.sections\` in ${readTool}, e.g. summary, scope, apiDesign. An id that does not exist yet adds a section.`);
 }
 const sectionContentInput = z.string().describe("The full new Markdown text of the section; it replaces the old text");
-const tenantDocumentType = z.enum(TENANT_DOCUMENT_TYPES).describe(`Document type: a policy (${named$1(POLICY_TYPES)}) or ${named$1(OTHER_TENANT_DOCUMENT_TYPES)}`);
+const tenantDocumentType = z.enum(TENANT_DOCUMENT_TYPES).describe("Document type: the policy_* ones are policies");
 /** Everything the model needs back from a write, without the content it already holds. */
 function documentSummary(doc) {
 	const { data, ...rest } = doc;
@@ -3378,42 +3367,42 @@ async function publishDraft(scope) {
 	});
 }
 function registerDocumentTools(server, client) {
-	if (client.hasCapability("tenant:documents:read")) {
-		server.registerTool("taiga_list_documents", {
-			title: "List company documents",
-			description: `List the organization's documents as summaries (type, name, description, version, draft state). The ${POLICY_TYPES.length} policies (${named$1(POLICY_TYPES)}) set the security, data privacy, SDLC, operations, architecture and compliance rules for every product; the others (${named$1(OTHER_TENANT_DOCUMENT_TYPES)}) carry goals, standards, voice and standing instructions. taiga_get_document reads one.`,
-			inputSchema: z.object({ ...pagination }),
-			annotations: READ_ONLY
-		}, (params) => runTool(async () => {
-			const result = await client.listTenantDocuments(params);
+	if (client.hasCapability("tenant:documents:read")) server.registerTool("taiga_get_document", {
+		title: "Get company document",
+		description: `Read one of the organization's documents by type, or without type list them all (type, name, version, draft state). The ${POLICY_TYPES.length} policies (${named$1(POLICY_TYPES)}) set the rules for every product; the others (${named$1(OTHER_TENANT_DOCUMENT_TYPES)}) carry goals, standards, voice and instructions. Policies are long: pass sections: [] for the outline, then the section ids you need, or a control id such as SEC-5.1; unknownSections names ids it lacks. A miss says which documents are published and whether a draft exists. A section's source (template, overlay-<id>, cloud-preset:<providers>) and priority (core: every organization keeps it) do not change what it requires.`,
+		inputSchema: z.object({
+			type: tenantDocumentType.optional(),
+			sections: policySectionsInput,
+			...pagination
+		}),
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		if (params.type === void 0) {
+			if (params.sections) return toolError("VALIDATION_ERROR", "Name the document (type) to read its sections.");
+			const result = await client.listTenantDocuments({
+				limit: params.limit,
+				cursor: params.cursor
+			});
 			return toolResult(page(summaries(result.data), result.nextCursor));
-		}));
-		server.registerTool("taiga_get_document", {
-			title: "Get company document",
-			description: "Read one of the organization's documents (a policy, goals, standards). Policies are long: pass sections: [] for the outline, then the section ids you need, or a control id such as SEC-5.1; unknownSections names ids it lacks. A miss says which documents are published and whether a draft exists. A section's source (template, overlay-<id>, cloud-preset:<providers>) and priority (core: every organization keeps it) do not change what it requires.",
-			inputSchema: z.object({
-				type: tenantDocumentType,
-				sections: policySectionsInput
-			}),
-			annotations: READ_ONLY
-		}, (params) => runTool(async () => {
-			try {
-				const doc = stripProvenance((await client.getTenantDocument(params.type)).data);
-				return params.sections ? sectionReadResult(doc, params.sections, params.type, { controlIds: POLICY_TYPES.includes(params.type) }) : toolResult(doc);
-			} catch (error) {
-				if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
-				const [draft, all] = await Promise.allSettled([client.getTenantDocumentDraft(params.type), client.listTenantDocuments({ limit: 100 })]);
-				const parts = [`No published ${params.type}.`];
-				if (draft.status === "fulfilled") parts.push(draft.value.data ? "A draft exists; taiga_publish_document publishes it once the person asks." : "There is no draft either.");
-				else parts.push(failedLookup("The draft", draft.reason));
-				if (all.status === "fulfilled") {
-					const published = publishedList(all.value.data);
-					parts.push(published ? `Published documents: ${published}.` : "Nothing is published yet.");
-				} else parts.push(failedLookup("The published list", all.reason));
-				return toolError("NOT_FOUND", parts.join(" "));
-			}
-		}));
-	}
+		}
+		const type = params.type;
+		if (params.limit !== void 0 || params.cursor !== void 0) return toolError("VALIDATION_ERROR", "limit and cursor page the list; omit type to list, or drop them to read.");
+		try {
+			const doc = stripProvenance((await client.getTenantDocument(type)).data);
+			return params.sections ? sectionReadResult(doc, params.sections, type, { controlIds: POLICY_TYPES.includes(type) }) : toolResult(doc);
+		} catch (error) {
+			if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
+			const [draft, all] = await Promise.allSettled([client.getTenantDocumentDraft(type), client.listTenantDocuments({ limit: 100 })]);
+			const parts = [`No published ${type}.`];
+			if (draft.status === "fulfilled") parts.push(draft.value.data ? "A draft exists; taiga_publish_document publishes it once the person asks." : "There is no draft either.");
+			else parts.push(failedLookup("The draft", draft.reason));
+			if (all.status === "fulfilled") {
+				const published = publishedList(all.value.data);
+				parts.push(published ? `Published documents: ${published}.` : "Nothing is published yet.");
+			} else parts.push(failedLookup("The published list", all.reason));
+			return toolError("NOT_FOUND", parts.join(" "));
+		}
+	}));
 	if (client.hasCapability("tenant:documents:read") && client.hasCapability("tenant:documents:write")) {
 		const tenantScope = (type) => ({
 			getDraft: () => client.getTenantDocumentDraft(type),
@@ -3438,41 +3427,27 @@ function registerDocumentTools(server, client) {
 			annotations: PUBLISH
 		}, (params) => runTool(() => publishDraft(tenantScope(params.type))));
 	}
-	if (client.hasCapability("factories:read")) {
-		server.registerTool("taiga_list_factory_documents", {
-			title: "List factory documents",
-			description: `List a factory's documents, published and draft (isDraft), as summaries (type, name, version). The only type is ${named$1(FACTORY_DOCUMENT_TYPES)}: standing guidance (domain context, tech preferences, conventions) for every product in the factory. An empty list means no publication or draft exists. taiga_get_factory_document reads it.`,
-			inputSchema: z.object({
-				factoryId: idInput("factory", "taiga_list_factories (query finds one by name) gives it"),
-				...pagination
-			}),
-			annotations: READ_ONLY
-		}, (params) => runTool(async () => {
-			const result = await client.listFactoryDocuments(params.factoryId, params);
-			return toolResult(page(summaries(result.data), result.nextCursor));
-		}));
-		server.registerTool("taiga_get_factory_document", {
-			title: "Get factory instructions",
-			description: "Read a factory's instructions: the domain context, tech preferences and conventions its products follow. If nothing is published, it says whether a draft exists and how to write one.",
-			inputSchema: z.object({
-				factoryId: idInput("factory", "taiga_list_factories (query finds one by name) gives it"),
-				type: z.enum(FACTORY_DOCUMENT_TYPES).default("factory_instructions").describe("Document type")
-			}),
-			annotations: READ_ONLY
-		}, (params) => runTool(async () => {
-			try {
-				return toolResult(stripProvenance((await client.getFactoryDocument(params.factoryId, params.type)).data));
-			} catch (error) {
-				if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
-				await client.getFactory(params.factoryId);
-				const detail = await client.getFactoryDocumentDraft(params.factoryId, params.type).then((draft) => draft.data ? "A draft exists; taiga_publish_factory_document publishes it once the person asks." : "There is no draft either: write one with taiga_update_factory_document, then publish it when the person asks.").catch((reason) => {
-					if (reason instanceof TaigaApiError && reason.status === 404) throw reason;
-					return failedLookup("The draft", reason);
-				});
-				return toolError("NOT_FOUND", `This factory has no published ${params.type} yet. ${detail}`);
-			}
-		}));
-	}
+	if (client.hasCapability("factories:read")) server.registerTool("taiga_get_factory_document", {
+		title: "Get factory instructions",
+		description: "Read a factory's instructions: the domain context, tech preferences and conventions its products follow. If nothing is published, it says whether a draft exists and how to write one.",
+		inputSchema: z.object({
+			factoryId: idInput("factory", "taiga_list_factories (query finds one by name) gives it"),
+			type: z.enum(FACTORY_DOCUMENT_TYPES).default("factory_instructions").describe("Document type")
+		}),
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		try {
+			return toolResult(stripProvenance((await client.getFactoryDocument(params.factoryId, params.type)).data));
+		} catch (error) {
+			if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
+			await client.getFactory(params.factoryId);
+			const detail = await client.getFactoryDocumentDraft(params.factoryId, params.type).then((draft) => draft.data ? "A draft exists; taiga_publish_factory_document publishes it once the person asks." : "There is no draft either: write one with taiga_update_factory_document, then publish it when the person asks.").catch((reason) => {
+				if (reason instanceof TaigaApiError && reason.status === 404) throw reason;
+				return failedLookup("The draft", reason);
+			});
+			return toolError("NOT_FOUND", `This factory has no published ${params.type} yet. ${detail}`);
+		}
+	}));
 	if (client.hasCapability("factories:read") && client.hasCapability("factories:documents:write")) {
 		const factoryScope = (factoryId, type) => ({
 			getDraft: () => client.getFactoryDocumentDraft(factoryId, type),
@@ -4840,7 +4815,7 @@ function registerMaintenanceTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
 	server.registerTool("taiga_list_findings", {
 		title: "List maintenance findings",
-		description: "List what maintenance sweeps found in a product's repository: dependencies, secrets, insecure code (sast) and infrastructure. The first page opens with sweep (open counts, latest sweeps), so an old or failed sweep is not read as an all-clear. Rows: severity, tier (act_now: known exploited; urgent: likely and serious; elevated: one of the two; routine), location, remediableBy (upstream_only: no fixed version), breached controls and initiativeId of a fix under way. Omit status for open findings. taiga_get_finding reads one.",
+		description: "List what maintenance sweeps found in a product's repository: dependencies, secrets, insecure code (sast) and infrastructure. The first page opens with sweep (open counts, latest sweeps), so an old or failed sweep is not read as an all-clear. Rows: severity, tier (act_now: known exploited; urgent: likely and serious; elevated: one of the two; routine), location, remediableBy (coding_agent: a run here can fix it; upstream_only: the code is in a submodule, so the fix belongs in its own repository), fixable: false when no fixed version is known yet, breached controls and initiativeId of a fix under way. Omit status for open findings. taiga_get_finding reads one.",
 		inputSchema: z.object({
 			productId,
 			status: z.enum(MAINTENANCE_FINDING_STATUSES).optional().describe("Only findings in this status; omit for the ones needing action"),
@@ -4953,7 +4928,7 @@ function registerMaintenanceTools(server, client) {
 			ignored: z.boolean().describe("true ignores the finding, false reopens it"),
 			reason: z.enum(MAINTENANCE_IGNORE_REASONS).optional().describe("Why it is ignored; required when ignoring"),
 			note: z.string().trim().max(280).optional().describe("A short justification, kept for audit"),
-			expiresAt: z.string().datetime({ offset: true }).optional().describe("When the ignore lapses and the finding resurfaces if it still exists (ISO 8601, in the future)")
+			expiresAt: z.string().datetime({ offset: true }).meta({ pattern: void 0 }).optional().describe("When the ignore lapses and the finding resurfaces if it still exists (ISO 8601, in the future)")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
@@ -4969,7 +4944,7 @@ function registerMaintenanceTools(server, client) {
 	}));
 	server.registerTool("taiga_fix_finding", {
 		title: "Fix a finding",
-		description: "Raise an initiative that fixes a maintenance finding, at the end of the product's line; it ends in a pull request a person merges, and the initiative's review gate applies. wholeGroup: true fixes the group in one initiative: every open advisory on that package version in one bump, or every location the same rule flagged. Refused for a secret only in history, anything in a submodule, and remediableBy upstream_only.",
+		description: "Raise an initiative that fixes a maintenance finding, at the end of the product's line; it ends in a pull request a person merges, and the initiative's review gate applies. wholeGroup: true fixes the group in one initiative: every open advisory on that package version in one bump, or every location the same rule flagged. Refused for a secret only in history, remediableBy upstream_only (code in a submodule), and a dependency with no fixed version yet (fixable: false).",
 		inputSchema: z.object({
 			productId,
 			findingId,
@@ -5046,14 +5021,14 @@ function readWith(row, backlogRead) {
 		case "backlog_item": return backlogRead ? "taiga_get_plan (initiativeId: subjectId)" : void 0;
 		case "product_document": {
 			const type = /^[^:]+:([a-z_]+):decision:/.exec(String(row["subjectId"]))?.[1];
-			return type ? `taiga_get_product_document (productId, type: ${type}); the decision's text is this row with full: true` : "taiga_list_product_documents (productId)";
+			return type ? `taiga_get_product_document (productId, type: ${type}); the decision's text is this row with full: true` : "taiga_get_product_document (productId, no type)";
 		}
 		case "inbox_task": return "taiga_list_setup_tasks (productId)";
 		case "product": return {
 			review_backlog: backlogRead ? "taiga_list_initiatives (productId)" : void 0,
 			review_maintenance: "taiga_list_findings (productId)",
 			review_policy: "taiga_get_policy_standing (productId)",
-			review_doc: "taiga_list_product_documents (productId)"
+			review_doc: "taiga_get_product_document (productId, no type)"
 		}[String(row["kind"])];
 		default: return;
 	}
@@ -5366,7 +5341,7 @@ function registerInboxTools(server, client) {
 				"done",
 				"dismissed"
 			]).optional().describe("What became of it"),
-			snoozedUntil: z.string().datetime().nullable().optional().describe("Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now")
+			snoozedUntil: z.string().datetime().meta({ pattern: void 0 }).nullable().optional().describe("Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
@@ -5399,7 +5374,7 @@ const REPOSITORY_SUMMARY_FIELDS = [
 	"isManaged"
 ];
 /** How many of the latest runs to carry; taiga_list_runs pages the rest. */
-const BUILDS_IN_CONTEXT = 10;
+const BUILDS_IN_CONTEXT = 5;
 /** A run as the bundle carries it: enough to say what was built and where; taiga_get_run has the rest. */
 const CONTEXT_BUILD_FIELDS = [
 	"id",
@@ -5418,6 +5393,7 @@ const CONTEXT_BUILD_FIELDS = [
 	"prDraft",
 	"reviewEscalation",
 	"error",
+	"hardeningResult",
 	"createdAt"
 ];
 /**
@@ -5586,7 +5562,7 @@ async function documentsPart(client, product, depth) {
 			}
 		} else if (isNotFound$1(read.reason)) {
 			out[type] = null;
-			notes.push(`No published ${origin} ${type}; taiga_list_product_documents shows what the product has.`);
+			notes.push(`No published ${origin} ${type}; taiga_get_product_document without type shows what the product has.`);
 		} else throw read.reason;
 	});
 	return {
@@ -5669,8 +5645,21 @@ async function repositoriesPart(links) {
 async function buildsPart(client, productId) {
 	const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data;
 	const states = await initiativeStates(client, rows);
-	return pickFields(rows, CONTEXT_BUILD_FIELDS).map(readableRow).map((row) => withInitiativeState(row, states));
+	return pickFields(rows, CONTEXT_BUILD_FIELDS).map(readableRow).map((row) => withInitiativeState(row, states)).map((row) => pickFields([row], CONTEXT_RUN_SAID)[0]);
 }
+/** A run in the bundle: which one, for what, how it ended, and its pull request. taiga_get_run has the rest. */
+const CONTEXT_RUN_SAID = [
+	"id",
+	"runNumber",
+	"backlogItemId",
+	"targetTitle",
+	"disposition",
+	"outcome",
+	"failedReasonMeans",
+	"hardeningNote",
+	"prUrl",
+	"createdAt"
+];
 /**
 * What waits on a person for this product, counted as taiga_list_action_required's summary counts it (PRO-2800):
 * the reviewing agent called four tools to answer "how does it stand", and two later reviews found this count and
@@ -5767,7 +5756,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 with a count per board column (byColumn; 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.`,
+		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 with a count per board column (byColumn; taiga_list_initiatives status: 'all' has the done and canceled), repositories, the latest five runs (taiga_list_runs has more), 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(),
@@ -6252,7 +6241,7 @@ function registerObserveTools(server, client) {
 //#endregion
 //#region src/tools/product-documents.ts
 const EDITABLE_TYPES = PRODUCT_DOCUMENT_TYPES.filter((type) => type !== "codebase_snapshot");
-const documentType = z.enum(EDITABLE_TYPES).describe("Document type -- taiga_list_product_documents shows which ones the product has");
+const documentType = z.enum(EDITABLE_TYPES).describe("Document type -- taiga_get_product_document without type shows which ones the product has");
 /** The documents a person reviews: the discovery chain, not the snapshot or the product's own instructions. */
 const reviewableType = z.enum(REVIEWABLE_PRODUCT_DOCUMENT_TYPES).describe("Document type -- one of the discovery documents a person reviews");
 /** The documents an agent writes from other documents; the same table the worker reads its inputs from. */
@@ -20979,7 +20968,7 @@ function registerPrompts(server, client) {
 			client.hasCapability("factories:read") ? client.getFactoryDocument(String(product.factoryId), "factory_instructions") : Promise.reject(new NotGranted("factories:read")),
 			client.hasCapability("tenant:documents:read") ? client.listTenantDocuments({ limit: 100 }) : Promise.reject(new NotGranted("tenant:documents:read"))
 		]);
-		const architectureText = architecture.status === "fulfilled" ? fence("markdown", renderDocument(stripProvenance(architecture.value.data)).text) : isNotFound(architecture.reason) ? `(No published ${origin} architecture; taiga_list_product_documents shows what exists.)` : unreadable("The architecture", architecture.reason);
+		const architectureText = architecture.status === "fulfilled" ? fence("markdown", renderDocument(stripProvenance(architecture.value.data)).text) : isNotFound(architecture.reason) ? `(No published ${origin} architecture; taiga_get_product_document without type shows what exists.)` : unreadable("The architecture", architecture.reason);
 		const instructionsText_ = instructions.status === "fulfilled" ? fence("markdown", instructionsText(sectionsOf(instructions.value.data.data) ?? {}) ?? "(The factory instructions are empty.)") : instructions.reason instanceof NotGranted ? instructions.reason.line("The factory instructions") : isNotFound(instructions.reason) ? "(This factory has not published instructions.)" : unreadable("The factory instructions", instructions.reason);
 		const policiesText = policies.status === "fulfilled" ? fence("text", policies.value.data.filter((row) => POLICY_TYPES.includes(String(row.type)) && row.isDraft === false).map((row) => `- ${String(row.type)}: ${Object.keys(sectionsOf(row.data ?? {}) ?? {}).join(", ")}`).join("\n") || "(No policy is published.)") : policies.reason instanceof NotGranted ? policies.reason.line("The policies") : unreadable("The policies", policies.reason);
 		return message([
@@ -21070,7 +21059,8 @@ const GITHUB_REPOSITORY_FIELDS = [
 	"defaultBranch",
 	"description",
 	"language",
-	"linked"
+	"linked",
+	"linkedProduct"
 ];
 const repositoryId = idInput("repository link", "taiga_list_product_repositories gives it; a linkable repository id is not one");
 /** Round-robin over lists: the first of each, then the second of each, and so on. */
@@ -21086,7 +21076,8 @@ function interleave(lists) {
 */
 async function holderOf(client, error, productId) {
 	if (!(error instanceof TaigaApiError) || error.status !== 409) return null;
-	const name = /^(\S+\/\S+) is already linked to another product\.?$/.exec(error.apiMessage ?? "")?.[1];
+	if (error.details?.["holder"]) return null;
+	const name = /^(\S+\/\S+) is already linked to another product\./.exec(error.apiMessage ?? "")?.[1];
 	if (!name) return null;
 	try {
 		const holders = (await client.listProducts({
@@ -21148,7 +21139,7 @@ function registerRepositoryTools(server, client) {
 	}
 	if (client.hasCapability("vcs:read")) server.registerTool("taiga_list_linkable_repositories", {
 		title: "Find a repository to link",
-		description: "List the repositories the organization's GitHub connection can reach, to link one with taiga_link_repository (it takes the row's id as linkableRepositoryId). query searches by name; account (login, owner, or installationId) reads one account, else rows come from every account in turn. linked: true means a product already links it (taiga_get_product with its URL says which). No connection means GitHub is not connected yet; someone who can install the app does that once, in the web.",
+		description: "List the repositories the organization's GitHub connection can reach, to link one with taiga_link_repository (it takes the row's id as linkableRepositoryId). query searches by name; account (login, owner, or installationId) reads one account, else rows come from every account in turn. linked: true means a product already links it, and linkedProduct names it to a key that sees every product. No connection means GitHub is not connected yet; someone who can install the app does that once, in the web.",
 		inputSchema: z.object({
 			query: z.string().trim().min(1).max(256).optional().describe("Part of the repository name"),
 			account: z.string().trim().min(1).max(140).optional().describe("The GitHub account login (the owner in owner/repo), case-insensitive"),
@@ -21339,7 +21330,7 @@ function registerResources(server, client) {
 			return requireOneOf("Document type", value, PRODUCT_DOCUMENT_TYPES);
 		};
 		const read = async (uri, productId, type, origin) => {
-			const result = await served(client.getProductDocument(productId, type, origin), `No published ${origin} ${type} for this product, or the key cannot see it; taiga_list_product_documents shows what exists`);
+			const result = await served(client.getProductDocument(productId, type, origin), `No published ${origin} ${type} for this product, or the key cannot see it; taiga_get_product_document without type shows what exists`);
 			return contents(uri.href, {
 				name: productDocumentName(type),
 				...result.data
@@ -21356,7 +21347,7 @@ function registerResources(server, client) {
 		});
 		server.registerResource("product-document", new ResourceTemplate("taiga://products/{productId}/documents/{type}", { list: void 0 }), {
 			title: "Product document",
-			description: "A product document from the product's own timeline (reality for an imported product, plan otherwise; the documents a person writes are always on the plan side). taiga_list_product_documents shows what exists; add ?origin=plan or ?origin=reality to read the other side. Markdown for a section map, JSON otherwise (the read says which)."
+			description: "A product document from the product's own timeline (reality for an imported product, plan otherwise; the documents a person writes are always on the plan side). taiga_get_product_document without type shows what exists; add ?origin=plan or ?origin=reality to read the other side. Markdown for a section map, JSON otherwise (the read says which)."
 		}, async (uri, variables) => {
 			const productId = requireId("Product ID", String(variables["productId"]));
 			const type = documentType(String(variables["type"]));

package/package.json

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

package/src/client.ts

@@ -345,14 +345,6 @@ export class TaigaClient {
   // Factory Documents
   // ---------------------------------------------------------------------------
 
-  async listFactoryDocuments(factoryId: string, opts?: { limit?: number | undefined; cursor?: string | undefined }) {
-    const params = new URLSearchParams();
-    if (opts?.limit) params.set('limit', String(opts.limit));
-    if (opts?.cursor) params.set('cursor', opts.cursor);
-    const qs = params.toString();
-    return this.request<Page<FactoryDocument>>('GET', `/factories/${seg(factoryId)}/documents${qs ? `?${qs}` : ''}`);
-  }
-
   async getFactoryDocument(factoryId: string, type: string) {
     return this.request<One<FactoryDocument>>('GET', `/factories/${seg(factoryId)}/documents/${seg(type)}`);
   }