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

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),
@@ -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 () => {
@@ -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([
@@ -21339,7 +21328,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 +21345,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.463",
   "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)}`);
   }

package/src/server.integration.test.ts

@@ -66,15 +66,12 @@ const ALL_TOOL_NAMES = [
   'taiga_ignore_finding',
   'taiga_link_repository',
   'taiga_list_action_required',
-  'taiga_list_documents',
   'taiga_list_environments',
   'taiga_list_factories',
-  'taiga_list_factory_documents',
   'taiga_list_findings',
   'taiga_list_initiatives',
   'taiga_list_knowledge',
   'taiga_list_linkable_repositories',
-  'taiga_list_product_documents',
   'taiga_list_product_repositories',
   'taiga_list_products',
   'taiga_list_repository_branches',
@@ -326,9 +323,7 @@ describe('MCP server integration', () => {
       const names = toolNames(tools);
 
       expect(names).toContain('taiga_list_factories');
-      expect(names).toContain('taiga_list_factory_documents');
       expect(names).toContain('taiga_get_factory_document');
-      expect(names).not.toContain('taiga_list_documents');
       expect(names).not.toContain('taiga_update_document');
     });
 
@@ -338,7 +333,6 @@ describe('MCP server integration', () => {
       const { tools } = await client.listTools();
       const names = toolNames(tools);
 
-      expect(names).toContain('taiga_list_documents');
       expect(names).toContain('taiga_get_document');
       expect(names).not.toContain('taiga_update_document');
     });
@@ -399,9 +393,7 @@ describe('MCP server integration', () => {
 
       // teams:read tools present
       expect(names).toContain('taiga_list_factories');
-      expect(names).toContain('taiga_list_factory_documents');
       // tenant:documents:read tools present
-      expect(names).toContain('taiga_list_documents');
       // write tools absent
       expect(names).not.toContain('taiga_update_document');
     });
@@ -438,7 +430,6 @@ describe('MCP server integration', () => {
         'taiga_list_products',
         'taiga_get_product',
         'taiga_get_product_context',
-        'taiga_list_product_documents',
         'taiga_get_product_document',
         'taiga_list_runs',
         'taiga_get_run',
@@ -467,8 +458,8 @@ describe('MCP server integration', () => {
       ],
       'vcs:manage': ['taiga_link_repository', 'taiga_set_repository_branch', 'taiga_unlink_repository'],
       'backlog:read': ['taiga_list_initiatives', 'taiga_get_initiative', 'taiga_get_plan', 'taiga_wait_for_initiative'],
-      'factories:read': ['taiga_list_factories', 'taiga_list_factory_documents', 'taiga_get_factory_document'],
-      'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document'],
+      'factories:read': ['taiga_list_factories', 'taiga_get_factory_document'],
+      'tenant:documents:read': ['taiga_get_document'],
       'customDocuments:read': ['taiga_list_knowledge', 'taiga_get_knowledge'],
     };
     const PAIRED_CONTRACT: Record<string, string[]> = {
@@ -562,7 +553,7 @@ describe('MCP server integration', () => {
         routes: { 'GET /v1/tenants/current/documents': { data: [doc], nextCursor: null } },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_documents', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_get_document', arguments: {} });
 
       expect(parseToolResult(result).data).toEqual([
         {
@@ -1292,7 +1283,7 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_list_product_documents',
+        name: 'taiga_get_product_document',
         arguments: { productId: PRODUCT_ID },
       });
 
@@ -1426,7 +1417,7 @@ describe('MCP server integration', () => {
         arguments: { productId: PRODUCT_ID, type: 'architecture' },
       });
       const list = await client.callTool({
-        name: 'taiga_list_product_documents',
+        name: 'taiga_get_product_document',
         arguments: { productId: PRODUCT_ID },
       });
 
@@ -1565,7 +1556,7 @@ describe('MCP server integration', () => {
       });
 
       const result = await client.callTool({
-        name: 'taiga_list_product_documents',
+        name: 'taiga_get_product_document',
         arguments: { productId: PRODUCT_ID },
       });
 
@@ -1604,7 +1595,7 @@ describe('MCP server integration', () => {
       });
 
       const parsed = parseToolResult(
-        await client.callTool({ name: 'taiga_list_product_documents', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_product_document', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(parsed.plan[0].outdated).toBe(false);
@@ -1623,7 +1614,7 @@ describe('MCP server integration', () => {
       });
 
       const parsed = parseToolResult(
-        await client.callTool({ name: 'taiga_list_product_documents', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_product_document', arguments: { productId: PRODUCT_ID } })
       );
 
       expect(parsed.plan[0]).not.toHaveProperty('outdated');
@@ -1642,7 +1633,7 @@ describe('MCP server integration', () => {
       });
 
       const list = parseToolResult(
-        await client.callTool({ name: 'taiga_list_product_documents', arguments: { productId: PRODUCT_ID } })
+        await client.callTool({ name: 'taiga_get_product_document', arguments: { productId: PRODUCT_ID } })
       );
       const miss = parseToolResult(
         await client.callTool({
@@ -1941,7 +1932,7 @@ describe('MCP server integration', () => {
         nextCursor: null,
       },
       [`GET /v1/products/${PRODUCT_ID}/repositories`]: { data: [repo], nextCursor: null },
-      [`GET /v1/products/${PRODUCT_ID}/builds?limit=10`]: { data: [run], nextCursor: null },
+      [`GET /v1/products/${PRODUCT_ID}/builds?limit=5`]: { data: [run], nextCursor: null },
       [`GET /v1/products/${PRODUCT_ID}/inbox`]: {
         data: [
           { id: 'i1', kind: 'review_pr', status: 'open' },
@@ -2003,7 +1994,7 @@ describe('MCP server integration', () => {
       });
       expect(bundle.documents.architecture).toBeNull();
       expect(bundle.documents.notes).toEqual([
-        'No published plan architecture; taiga_list_product_documents shows what the product has.',
+        'No published plan architecture; taiga_get_product_document without type shows what the product has.',
       ]);
       expect(bundle.policies).toEqual([{ type: 'policy_security', name: 'Security Policy', version: 3, sections: 2 }]);
       expect(bundle.initiatives.items.map((row: { id: string }) => row.id)).toEqual([ITEM_ID]);
@@ -2026,9 +2017,9 @@ describe('MCP server integration', () => {
       });
       expect(bundle.runs).toEqual([
         {
+          // The disposition says how it ended; status, the raw word, is taiga_get_run's (PRO-2800).
           id: BUILD_ID,
           runNumber: 1,
-          status: 'completed',
           targetTitle: 'Add login',
           disposition: 'unmerged',
           outcome: 'Settled without a merged pull request.',
@@ -2364,13 +2355,7 @@ describe('MCP server integration', () => {
     it.each([
       ['taiga_list_factories', {}, '/v1/factories', ['factories:read']],
       ['taiga_list_products', {}, '/v1/products', ['products:read']],
-      ['taiga_list_documents', {}, '/v1/tenants/current/documents', ['tenant:documents:read']],
-      [
-        'taiga_list_factory_documents',
-        { factoryId: FACTORY_ID },
-        `/v1/factories/${FACTORY_ID}/documents`,
-        ['factories:read'],
-      ],
+      ['taiga_get_document', {}, '/v1/tenants/current/documents', ['tenant:documents:read']],
       [
         'taiga_list_initiatives',
         { productId: PRODUCT_ID, status: 'all' },
@@ -2567,7 +2552,7 @@ describe('MCP server integration', () => {
       expect(String((own as Error).message)).toContain('403 FORBIDDEN: Not a member of this product');
       expect(named).toMatchObject({ code: -32602 });
       expect(String((named as Error).message)).toContain(
-        'taiga_list_product_documents shows what exists (403 FORBIDDEN'
+        'taiga_get_product_document without type shows what exists (403 FORBIDDEN'
       );
     });
 
@@ -2640,7 +2625,7 @@ describe('MCP server integration', () => {
       [`GET /v1/products/${PRODUCT_ID}/backlog?status=backlog&limit=100`]: { data: [], nextCursor: null },
       [`GET /v1/products/${PRODUCT_ID}/backlog?status=in_progress&limit=100`]: { data: [item], nextCursor: null },
       [`GET /v1/products/${PRODUCT_ID}/repositories`]: { data: [], nextCursor: null },
-      [`GET /v1/products/${PRODUCT_ID}/builds?limit=10`]: { data: [], nextCursor: null },
+      [`GET /v1/products/${PRODUCT_ID}/builds?limit=5`]: { data: [], nextCursor: null },
       'GET /v1/products?slug=web&limit=1': { data: [product], nextCursor: null },
     };
 
@@ -2731,7 +2716,9 @@ describe('MCP server integration', () => {
         .catch((e: unknown) => e);
 
       expect(failure).toMatchObject({ code: -32602 });
-      expect(String((failure as Error).message)).toContain('taiga_list_products shows the ones it can');
+      expect(String((failure as Error).message)).toContain(
+        'taiga_list_products (query finds one by name) shows the ones it can; a slug or git remote URL names one too.'
+      );
     });
 
     it('should refuse a session with no product named', async () => {
@@ -8427,7 +8414,7 @@ describe('what the sixth agent review found (PRO-2800)', () => {
     expect(plan.summary.length).toBeLessThan(240);
     expect(doc).not.toHaveProperty('status');
     expect(doc).not.toHaveProperty('blocking');
-    expect(doc.readWith).toBe('taiga_list_product_documents (productId)');
+    expect(doc.readWith).toBe('taiga_get_product_document (productId, no type)');
     expect(plan.blocking).toBe(true);
     expect(plan.readWith).toBe('taiga_get_plan (initiativeId: subjectId)');
     expect(task.status).toBe('in_progress');
@@ -8606,6 +8593,9 @@ describe('what the seventh agent review found (PRO-2800)', () => {
     const refused = await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: 'my item' } });
 
     expect(listing).not.toMatch(/"pattern":"\^\(\[0-9a-fA-F\]\{8\}/);
+    // Nor the date-time one: a pattern left is a short one that says something (a slug, a file extension).
+    const patterns = [...listing.matchAll(/"pattern":"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1]!);
+    expect(patterns.filter((pattern) => pattern.length > 60)).toEqual([]);
     expect(listing).toMatch(/"format":"uuid"/);
     expect(JSON.stringify(refused.content)).toMatch(/An initiative ID is a UUID/);
   });
@@ -8813,4 +8803,49 @@ describe('what the seventh agent review found (PRO-2800)', () => {
     expect(critical).not.toHaveProperty('totalNote');
     expect(secrets).not.toHaveProperty('totalNote');
   });
+
+  it('reads a document by type and lists them without one, refusing sections with nothing to read', async () => {
+    const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
+
+    const company = parseToolResult(await client.callTool({ name: 'taiga_get_document', arguments: { sections: [] } }));
+    const product = parseToolResult(
+      await client.callTool({
+        name: 'taiga_get_product_document',
+        arguments: { productId: PRODUCT_ID, origin: 'plan' },
+      })
+    );
+
+    expect(company).toMatchObject({ error: 'VALIDATION_ERROR' });
+    expect(product).toMatchObject({ error: 'VALIDATION_ERROR' });
+  });
+
+  it("keeps a run's hardening note in the compact context row", async () => {
+    const { client } = await bootMcpPair({
+      capabilities: ['products:read'],
+      routes: {
+        [`GET /v1/products/${PRODUCT_ID}`]: {
+          data: { id: PRODUCT_ID, name: 'Web', status: 'active', factoryId: FACTORY_ID, settings: {} },
+        },
+        [`/v1/products/${PRODUCT_ID}/builds`]: {
+          data: [
+            {
+              id: BUILD_ID,
+              status: 'completed',
+              prMerged: true,
+              prNumber: 3,
+              hardeningResult: { passed: false, blockingFindings: 2 },
+            },
+          ],
+          nextCursor: null,
+        },
+      },
+    });
+
+    const bundle = parseToolResult(
+      await client.callTool({ name: 'taiga_get_product_context', arguments: { productId: PRODUCT_ID } })
+    );
+
+    expect(bundle.runs[0].hardeningNote).toMatch(/^Hardening ended with 2 blocking findings/);
+    expect(bundle.runs[0]).not.toHaveProperty('hardeningResult');
+  });
 });

package/src/tools/catalogue.test.ts

@@ -102,8 +102,9 @@ describe('tool descriptions against the catalogue', () => {
 
   it('names every policy where the company documents are explained', async () => {
     const tools = await allTools();
-    const list = tools.find((t) => t.name === 'taiga_list_documents')!;
+    // One tool lists and reads the company documents.
     const get = tools.find((t) => t.name === 'taiga_get_document')!;
+    const list = get;
     const typeEnum = (get.inputSchema.properties as Record<string, { enum?: string[] }>)['type']!.enum;
 
     for (const type of POLICY_TYPES) {

package/src/tools/catalogue.ts

@@ -182,7 +182,7 @@ export function setupNextStep(
         );
       case 'complete':
         return (
-          'The import is done: review the reality documents (taiga_list_product_documents), then ' +
+          'The import is done: review the reality documents (taiga_get_product_document without type), then ' +
           'taiga_finish_discovery opens the product.'
         );
       case 'failed':

package/src/tools/context.ts

@@ -56,7 +56,7 @@ const REPOSITORY_SUMMARY_FIELDS = [
 ] as const;
 
 /** 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 = [
@@ -76,6 +76,8 @@ const CONTEXT_BUILD_FIELDS = [
   'prDraft',
   'reviewEscalation',
   'error',
+  // Read for hardeningNote; the compact row drops it.
+  'hardeningResult',
   'createdAt',
 ] as const;
 
@@ -240,7 +242,7 @@ async function documentsPart(client: TaigaClient, product: WithoutTenant<Product
       }
     } else if (isNotFound(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 { ...out, notes };
@@ -337,11 +339,29 @@ async function repositoriesPart(links: () => ReturnType<TaigaClient['listProduct
 async function buildsPart(client: TaigaClient, productId: string) {
   const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data as Record<string, unknown>[];
   const states = await initiativeStates(client, rows);
+  // The fields the outcome is made from are read, then the row is cut to what the bundle says: each run with its
+  // two-sentence outcome and every PR field was half the context, repeated by taiga_list_runs (PRO-2800).
   return pickFields(rows, CONTEXT_BUILD_FIELDS)
     .map(readableRow)
-    .map((row) => withInitiativeState(row, states));
+    .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',
+  // Rare and short, and what the outcome sentence does not say.
+  'failedReasonMeans',
+  'hardeningNote',
+  'prUrl',
+  'createdAt',
+] as const;
+
 /**
  * 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
@@ -466,7 +486,7 @@ export function registerContextTools(server: McpServer, client: TaigaClient) {
         '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 ' +
+        '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 / 1000}k ` +
         'characters each, full returns all.',

package/src/tools/documents.ts

@@ -75,7 +75,8 @@ export const sectionContentInput = z
   .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(POLICY_TYPES)}) or ${named(OTHER_TENANT_DOCUMENT_TYPES)}`);
+  // The enum lists every type; the description only says which are policies.
+  .describe('Document type: the policy_* ones are policies');
 
 /**
  * The read, save and publish calls for one document scope. The tools are the
@@ -150,52 +151,48 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
   // ── Company-level policy documents ──────────────────────────────────
 
   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(POLICY_TYPES)}) set the security, data privacy, SDLC, ` +
-          'operations, architecture and compliance rules for every product; the others ' +
-          `(${named(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);
-          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 " +
+          "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(POLICY_TYPES)}) set the rules for every ` +
+          `product; the others (${named(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,
+          type: tenantDocumentType.optional(),
           sections: policySectionsInput,
+          ...pagination,
         }),
         annotations: READ_ONLY,
       },
       (params) =>
         runTool(async () => {
+          // One tool for the list and the read (PRO-2800): the catalogue's weight is the cost every review ranks
+          // first, and a list tool beside each read was the read without a type.
+          if (params.type === undefined) {
+            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));
+          }
+          const type = params.type;
+          if (params.limit !== undefined || params.cursor !== undefined) {
+            return toolError(
+              'VALIDATION_ERROR',
+              'limit and cursor page the list; omit type to list, or drop them to read.'
+            );
+          }
           try {
-            const result = await client.getTenantDocument(params.type);
+            const result = await client.getTenantDocument(type);
             const doc = stripProvenance(result.data);
             return params.sections
-              ? sectionReadResult(doc, params.sections, params.type, {
-                  controlIds: (POLICY_TYPES as readonly string[]).includes(params.type),
+              ? sectionReadResult(doc, params.sections, type, {
+                  controlIds: (POLICY_TYPES as readonly string[]).includes(type),
                 })
               : toolResult(doc);
           } catch (error) {
@@ -203,10 +200,10 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
             // Best effort, each part on its own: a failed lookup must not turn
             // a miss into an outage, nor blank the part that did answer.
             const [draft, all] = await Promise.allSettled([
-              client.getTenantDocumentDraft(params.type),
+              client.getTenantDocumentDraft(type),
               client.listTenantDocuments({ limit: 100 }),
             ]);
-            const parts = [`No published ${params.type}.`];
+            const parts = [`No published ${type}.`];
             if (draft.status === 'fulfilled') {
               parts.push(
                 draft.value.data
@@ -277,28 +274,6 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
   // ── Factory instructions ────────────────────────────────────────────
 
   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(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',
       {

package/src/tools/inbox.ts

@@ -63,7 +63,7 @@ function readWith(row: Row, backlogRead: boolean): string | undefined {
       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)';
+        : 'taiga_get_product_document (productId, no type)';
     }
     case 'inbox_task':
       return 'taiga_list_setup_tasks (productId)';
@@ -73,7 +73,7 @@ function readWith(row: Row, backlogRead: boolean): string | undefined {
         review_backlog: backlogRead ? 'taiga_list_initiatives (productId)' : undefined,
         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 undefined;
@@ -517,6 +517,8 @@ export function registerInboxTools(server: McpServer, client: TaigaClient) {
         snoozedUntil: z
           .string()
           .datetime()
+          // format: date-time says it; the leap-year pattern beside it ran to hundreds of characters (PRO-2800).
+          .meta({ pattern: undefined })
           .nullable()
           .optional()
           .describe('Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now'),

package/src/tools/maintenance.ts

@@ -429,6 +429,8 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         expiresAt: z
           .string()
           .datetime({ offset: true })
+          // format: date-time says it; the leap-year pattern beside it ran to hundreds of characters (PRO-2800).
+          .meta({ pattern: undefined })
           .optional()
           .describe('When the ignore lapses and the finding resurfaces if it still exists (ISO 8601, in the future)'),
       }),

package/src/tools/product-documents.ts

@@ -34,7 +34,7 @@ const EDITABLE_TYPES = PRODUCT_DOCUMENT_TYPES.filter((type): type is EditableTyp
 
 const documentType = z
   .enum(EDITABLE_TYPES)
-  .describe('Document type -- taiga_list_product_documents shows which ones the product has');
+  .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

package/src/tools/products.ts

@@ -279,7 +279,7 @@ export async function resolveProductRef(
       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. 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.`
       );
     }
@@ -470,41 +470,23 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
         })
     );
 
-    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 () => {
-          // `unlistable` is how a miss message is built; the list says the
-          // same in its notes and a null side.
-          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.',
+          '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'),
+            .optional()
+            .describe('Document type; omit to list what the product has on both timelines'),
           origin: originInput,
           sections: sectionsInput,
         }),
@@ -512,16 +494,25 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
       },
       (params) =>
         runTool(async () => {
+          // Without a type, the list of both timelines (PRO-2800): one tool where a list tool stood beside it.
+          if (params.type === undefined) {
+            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;
           // The product's own timeline when none is asked for; the API's
           // default is plan, which is the wrong side of an imported product.
           let product: ProductSettingsView | undefined;
           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 result = await client.getProductDocument(params.productId, params.type, origin);
+            const result = await client.getProductDocument(params.productId, type, origin);
             const doc = stripProvenance(result.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;
             // A product the key cannot see is a product miss, not a document
@@ -530,7 +521,7 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
             // propagates, as the API failing.
             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, timelines, product));
           }
         })
     );

package/src/tools/prompts.ts

@@ -148,7 +148,7 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
           architecture.status === 'fulfilled'
             ? fenced('markdown', renderDocument(stripProvenance(architecture.value.data)).text)
             : isNotFound(architecture.reason)
-              ? `(No published ${origin} architecture; taiga_list_product_documents shows what exists.)`
+              ? `(No published ${origin} architecture; taiga_get_product_document without type shows what exists.)`
               : unreadable('The architecture', architecture.reason);
         const instructionsText_ =
           instructions.status === 'fulfilled'

package/src/tools/readiness.ts

@@ -144,10 +144,10 @@ function nextStepFor(state: {
         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.'
+            '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_list_product_documents), then ${finish}`;
+        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).';
     }

package/src/tools/resources.ts

@@ -142,7 +142,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
     const read = async (uri: URL, productId: string, type: ProductDocumentType, origin: ProductDocumentOrigin) => {
       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`
+        `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 });
     };
@@ -173,7 +173,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
         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 ' +
+          '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).',
       },

package/src/tools/sections.ts

@@ -272,7 +272,7 @@ export function sectionReadResult(
     ? {
         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.`,
+          : `${asControl} looks like a policy control id, which only a policy resolves: taiga_get_document without type lists them.`,
       }
     : {};
   if (known.length === 0) {