@taiga-ai/mcp-server 0.5.0-rc.389 → 0.6.0-dev.391

package/dist/index.js

@@ -95,7 +95,10 @@ var TaigaClient = class {
 		const params = new URLSearchParams();
 		if (opts?.factoryId) params.set("factoryId", opts.factoryId);
 		if (opts?.status) params.set("status", opts.status);
+		if (opts?.repository) params.set("repository", opts.repository);
+		if (opts?.repositoryHost) params.set("repositoryHost", opts.repositoryHost);
 		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", `/products${qs ? `?${qs}` : ""}`);
 	}
@@ -149,63 +152,12 @@ var TaigaClient = class {
 	async getProductDocument(productId, type) {
 		return this.request("GET", `/products/${seg(productId)}/documents/${seg(type)}`);
 	}
-	/**
-	* Fetch the full context for a product in parallel: product metadata,
-	* its factory's instructions and the product documents.
-	* Returns a structured bundle optimized for coding agent consumption.
-	*/
-	async getProductContext(productId) {
-		const product = await this.request("GET", `/products/${seg(productId)}`);
-		const factoryId = product.data.factoryId;
-		const [productDocs, factoryDocs] = await Promise.all([this.listProductDocuments(productId, { limit: 20 }).catch(() => ({ data: [] })), factoryId ? this.listFactoryDocuments(factoryId, { limit: 20 }).catch(() => ({ data: [] })) : Promise.resolve({ data: [] })]);
-		const keyProductDocTypes = [
-			"specification",
-			"architecture",
-			"technology_decisions"
-		];
-		const keyFactoryDocTypes = ["factory_instructions"];
-		const docFetches = [];
-		for (const docType of keyProductDocTypes) if (productDocs.data.some((d) => d.type === docType && !d.isDraft)) docFetches.push(this.getProductDocument(productId, docType).then((r) => ({
-			type: docType,
-			scope: "product",
-			data: r.data
-		})).catch(() => ({
-			type: docType,
-			scope: "product",
-			data: null
-		})));
-		if (factoryId) {
-			for (const docType of keyFactoryDocTypes) if (factoryDocs.data.some((d) => d.type === docType && !d.isDraft)) docFetches.push(this.getFactoryDocument(factoryId, docType).then((r) => ({
-				type: docType,
-				scope: "factory",
-				data: r.data
-			})).catch(() => ({
-				type: docType,
-				scope: "factory",
-				data: null
-			})));
-		}
-		const fetchedDocs = await Promise.all(docFetches);
-		const summarize = (docs) => docs.map((d) => ({
-			type: d.type,
-			name: d.name,
-			version: d.version,
-			isDraft: d.isDraft
-		}));
-		return {
-			product: product.data,
-			documents: {
-				product: Object.fromEntries(fetchedDocs.filter((d) => d.scope === "product" && d.data).map((d) => [d.type, d.data])),
-				factory: Object.fromEntries(fetchedDocs.filter((d) => d.scope === "factory" && d.data).map((d) => [d.type, d.data]))
-			},
-			available_documents: {
-				product: summarize(productDocs.data),
-				factory: summarize(factoryDocs.data)
-			}
-		};
-	}
 	async listBacklogItems(productId, opts) {
 		const params = new URLSearchParams();
+		if (opts?.status) params.set("status", opts.status);
+		if (opts?.planningStatus) params.set("planningStatus", opts.planningStatus);
+		if (opts?.category) params.set("category", opts.category);
+		if (opts?.includeArchived) params.set("includeArchived", "true");
 		if (opts?.limit) params.set("limit", String(opts.limit));
 		const qs = params.toString();
 		return this.request("GET", `/products/${seg(productId)}/backlog${qs ? `?${qs}` : ""}`);
@@ -213,8 +165,18 @@ var TaigaClient = class {
 	async getBacklogItem(itemId) {
 		return this.request("GET", `/backlog/${seg(itemId)}`);
 	}
-	async listEnvironments(productId) {
-		return this.request("GET", `/products/${seg(productId)}/environments`);
+	async listBuildRuns(productId, opts) {
+		const params = new URLSearchParams();
+		if (opts?.backlogItemId) params.set("backlogItemId", opts.backlogItemId);
+		if (opts?.limit) params.set("limit", String(opts.limit));
+		const qs = params.toString();
+		return this.request("GET", `/products/${seg(productId)}/builds${qs ? `?${qs}` : ""}`);
+	}
+	async getBuildRun(id) {
+		return this.request("GET", `/builds/${seg(id)}`);
+	}
+	async listBuildRunSteps(id) {
+		return this.request("GET", `/builds/${seg(id)}/steps`);
 	}
 	async listFactories(opts) {
 		const params = new URLSearchParams();
@@ -239,6 +201,18 @@ function readConfig() {
 	};
 }
 //#endregion
+//#region src/tools/annotations.ts
+/**
+* Tool annotations shared by every read tool. Hints for the client, not a
+* control: the API enforces what a key may do.
+*/
+const READ_ONLY = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: false
+};
+//#endregion
 //#region src/tools/errors.ts
 /** A successful tool result: one JSON text block the model reads. */
 function toolResult(value) {
@@ -300,6 +274,67 @@ async function runTool(handler) {
 */
 const documentType = z.string().regex(/^[a-z][a-z0-9_]{0,63}$/, "A document type is a lowercase identifier such as policy_security");
 //#endregion
+//#region src/tools/remote.ts
+const SCP_LIKE = /^(?:[^@\s/]+@)?([^:\s/]+):([^\s]+)$/;
+function parseRemote(remote) {
+	const trimmed = remote.trim();
+	if (trimmed === "") return null;
+	let host;
+	let path;
+	let scheme = "https";
+	if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
+		if (hasDotSegment(trimmed.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, ""))) return null;
+		let url;
+		try {
+			url = new URL(trimmed);
+		} catch {
+			return null;
+		}
+		const protocol = url.protocol.replace(/:$/, "").toLowerCase();
+		if (protocol === "http" || protocol === "https") {
+			scheme = protocol;
+			host = url.port ? `${url.hostname}:${url.port}` : url.hostname;
+		} else if (protocol === "ssh" || protocol === "git+ssh" || protocol === "git") host = url.hostname;
+		else return null;
+		path = url.pathname;
+	} else {
+		const match = SCP_LIKE.exec(trimmed);
+		if (!match) return null;
+		host = match[1];
+		path = match[2];
+		if (host.length < 2) return null;
+	}
+	host = host.toLowerCase();
+	if (host === "") return null;
+	const segments = path.replace(/\/+$/, "").replace(/\.git$/i, "").split("/").filter((segment) => segment !== "");
+	if (segments.length !== 2) return null;
+	if (hasDotSegment(path) || segments.some((segment) => segment.includes(":"))) return null;
+	const origin = webOrigin(`${scheme}://${host}`);
+	if (origin === null) return null;
+	return {
+		host: origin,
+		repository: `${segments[0]}/${segments[1]}`
+	};
+}
+/** Whether any segment of the path is `.` or `..`, percent-encoded or not. */
+function hasDotSegment(path) {
+	return path.split("/").some((segment) => {
+		let decoded = segment;
+		try {
+			decoded = decodeURIComponent(segment);
+		} catch {}
+		return decoded === "." || decoded === "..";
+	});
+}
+function webOrigin(url) {
+	try {
+		const origin = new URL(url).origin;
+		return origin === "null" ? null : origin;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/tools/summarize.ts
 /**
 * Strip heavy content from list responses to avoid context window bloat.
@@ -327,27 +362,78 @@ function summarizeList(items) {
 		return summary;
 	});
 }
+/**
+* Keep only the named fields of each item. For lists whose rows carry prose
+* (a backlog item's description, a run's metrics) that `summarizeList`'s
+* fixed field names would not catch.
+*/
+function pickFields(items, fields) {
+	return items.map((item) => {
+		const picked = {};
+		for (const field of fields) if (field in item) picked[field] = item[field];
+		return picked;
+	});
+}
 //#endregion
 //#region src/tools/products.ts
-const READ_ONLY$1 = {
-	readOnlyHint: true,
-	destructiveHint: false,
-	idempotentHint: true,
-	openWorldHint: false
-};
+/** What a product row needs to say for the model to pick one and read it in full. */
+const PRODUCT_SUMMARY_FIELDS = [
+	"id",
+	"name",
+	"slug",
+	"status",
+	"factoryId",
+	"kind",
+	"discoveryStep"
+];
+/** The API's page ceiling (paginationSchema in apps/api). */
+const PAGE_SIZE = 100;
+/**
+* Pages the resolver follows before it stops and says so. A repository is
+* linked to one product, or a handful where sharing is allowed; a thousand
+* matches is not a resolution the model can act on anyway.
+*/
+const RESOLVE_PAGE_LIMIT = 10;
+/**
+* Every product linked to the repository, page by page, until the API runs
+* out or the cap is hit. A page that fails fails the call, like every other
+* tool: a partial list marked truncated would read as a complete one.
+*/
+async function linkedProducts(client, repository, repositoryHost) {
+	const products = [];
+	let cursor;
+	for (let page = 0; page < RESOLVE_PAGE_LIMIT; page += 1) {
+		const result = await client.listProducts({
+			repository,
+			repositoryHost,
+			limit: PAGE_SIZE,
+			cursor
+		});
+		products.push(...result.data);
+		if (!result.nextCursor) return {
+			products,
+			truncated: false
+		};
+		cursor = result.nextCursor;
+	}
+	return {
+		products,
+		truncated: true
+	};
+}
 function registerProductTools(server, client) {
 	if (client.hasCapability("factories:read")) server.registerTool("taiga_list_factories", {
 		title: "List factories",
 		description: "List all factories in the organization. A factory is the group that owns a set of products. Use this to find factory IDs for reading factory instructions. Factory instructions carry the factory's standing guidance: domain context, tech preferences, and the conventions its products follow.",
-		inputSchema: { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") },
-		annotations: READ_ONLY$1
+		inputSchema: { limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)") },
+		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
 		return toolResult((await client.listFactories(params)).data);
 	}));
 	if (client.hasCapability("products:read")) {
 		server.registerTool("taiga_list_products", {
 			title: "List products",
-			description: "List products in the organization. Use this to find the product you are working on so you can read its specification, architecture, and threat model. Can filter by factory; a status filter also exists but no longer distinguishes anything (see its description).",
+			description: "List products in the organization. Use this to find a product by name; inside a git checkout, taiga_resolve_product finds it from the remote URL instead. Can filter by factory; a status filter also exists but no longer distinguishes anything (see its description).",
 			inputSchema: {
 				factoryId: z.string().uuid().optional().describe("Filter by factory ID -- get factory IDs from taiga_list_factories"),
 				status: z.enum([
@@ -355,20 +441,45 @@ function registerProductTools(server, client) {
 					"active",
 					"archived"
 				]).optional().describe("Filter by status. Taiga no longer surfaces product status in its UI (PRO-543), so every product is currently \"draft\" and filtering by \"active\" or \"archived\" returns nothing. Omit this unless you are working with data set through the API directly."),
-				limit: z.number().min(1).max(100).optional().describe("Max results (default 25)")
+				limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)")
 			},
-			annotations: READ_ONLY$1
+			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
-			return toolResult((await client.listProducts(params)).data);
+			return toolResult(pickFields((await client.listProducts(params)).data, PRODUCT_SUMMARY_FIELDS));
+		}));
+		server.registerTool("taiga_get_product", {
+			title: "Get product",
+			description: "Get one product in full: name, slug, factory, what Taiga owns for it (application, infrastructure, deployment) and its settings; the list and resolve tools carry summaries. Use taiga_list_product_documents for its specification and design, taiga_list_backlog_items for its work and taiga_list_builds for what the coding agent did.",
+			inputSchema: { productId: z.string().uuid().describe("Product ID -- get from taiga_resolve_product (from a git remote) or taiga_list_products") },
+			annotations: READ_ONLY
+		}, (params) => runTool(async () => {
+			return toolResult((await client.getProduct(params.productId)).data);
+		}));
+		server.registerTool("taiga_resolve_product", {
+			title: "Resolve product from git remote",
+			description: "Find the Taiga product a git checkout belongs to from its remote URL (the output of `git remote get-url origin`). Call this first when working inside a repository, then use the product ID with every other tool. Returns every product the repository is linked to (several when the organization shares repositories; `truncated` is true past 1000); NOT_FOUND means nobody linked it, or the key cannot see the product.",
+			inputSchema: { remoteUrl: z.string().min(1).max(2048).describe("The remote URL: https://github.com/owner/repo.git, git@github.com:owner/repo.git or ssh://...") },
+			annotations: READ_ONLY
+		}, (params) => runTool(async () => {
+			const remote = parseRemote(params.remoteUrl);
+			if (!remote) return toolError("INVALID_REMOTE", `"${params.remoteUrl}" is not a remote of the form host/owner/repo. Pass the URL git remote get-url origin prints.`);
+			const { products, truncated } = await linkedProducts(client, remote.repository, remote.host);
+			if (products.length === 0) return toolError("NOT_FOUND", `No product you can see is linked to ${remote.repository} on ${remote.host}. Link the repository to its product in Taiga, or find the product with taiga_list_products.`);
+			return toolResult({
+				repository: remote.repository,
+				host: remote.host,
+				products: pickFields(products, PRODUCT_SUMMARY_FIELDS),
+				truncated
+			});
 		}));
 		server.registerTool("taiga_list_product_documents", {
 			title: "List product documents",
 			description: "List documents for a specific product (names and types only). Product documents are generated during intake: specification (requirements), architecture (system design), technology decisions, data flow, privacy assessment, threat model (security risks), risk register, user flow, and service blueprint. Use taiga_get_product_document to read the full content.",
 			inputSchema: {
 				productId: z.string().uuid().describe("Product ID -- get from taiga_list_products"),
-				limit: z.number().min(1).max(100).optional().describe("Max results (default 25)")
+				limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)")
 			},
-			annotations: READ_ONLY$1
+			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
 			return toolResult(summarizeList((await client.listProductDocuments(params.productId, { limit: params.limit })).data));
 		}));
@@ -379,7 +490,7 @@ function registerProductTools(server, client) {
 				productId: z.string().uuid().describe("Product ID -- get from taiga_list_products"),
 				type: documentType.describe("Document type -- get available types from taiga_list_product_documents. Common: specification, architecture, threat_model, technology_decisions")
 			},
-			annotations: READ_ONLY$1
+			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
 			return toolResult((await client.getProductDocument(params.productId, params.type)).data);
 		}));
@@ -414,12 +525,6 @@ function applySectionEdit(sections, sectionId, content) {
 }
 //#endregion
 //#region src/tools/documents.ts
-const READ_ONLY = {
-	readOnlyHint: true,
-	destructiveHint: false,
-	idempotentHint: true,
-	openWorldHint: false
-};
 const DRAFT_WRITE = {
 	readOnlyHint: false,
 	destructiveHint: false,
@@ -488,7 +593,7 @@ function registerDocumentTools(server, client) {
 		server.registerTool("taiga_list_documents", {
 			title: "List company documents",
 			description: "List company-level policy documents (names and types only). Policies define security, data privacy, SDLC, operations, architecture, and compliance rules that apply across all factories and products. Use taiga_get_document with the document type to read the full policy content.",
-			inputSchema: { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") },
+			inputSchema: { limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)") },
 			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
 			return toolResult(summarizeList((await client.listTenantDocuments(params)).data));
@@ -532,7 +637,7 @@ function registerDocumentTools(server, client) {
 			description: "List documents for a specific factory (names and types only). A factory has one document: its instructions, the factory's free-form standing guidance (domain context, tech preferences, conventions) that applies to every product it owns. Use taiga_get_factory_document to read the full content.",
 			inputSchema: {
 				factoryId: z.string().uuid().describe("Factory ID -- get from taiga_list_factories"),
-				limit: z.number().min(1).max(100).optional().describe("Max results (default 25)")
+				limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)")
 			},
 			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
@@ -582,18 +687,129 @@ function registerDocumentTools(server, client) {
 	}
 }
 //#endregion
+//#region src/tools/backlogs.ts
+/** What a list row needs to say for the model to pick an item to read in full. */
+const BACKLOG_SUMMARY_FIELDS = [
+	"id",
+	"title",
+	"category",
+	"status",
+	"state",
+	"planningStatus",
+	"priority",
+	"estimate",
+	"origin",
+	"needsHumanCause",
+	"archivedAt",
+	"createdAt",
+	"updatedAt"
+];
+function registerBacklogTools(server, client) {
+	if (!client.hasCapability("backlog:read")) return;
+	server.registerTool("taiga_list_backlog_items", {
+		title: "List backlog items",
+		description: "List a product's backlog items (initiatives): titles, category, status and where each one is on the line (backlog, todo, queue, plan, build, done). Use this to find the item you are working on, then read its acceptance criteria and technical context with taiga_get_backlog_item. Archived items are left out unless asked for.",
+		inputSchema: {
+			productId: z.string().uuid().describe("Product ID -- get from taiga_resolve_product (from a git remote) or taiga_list_products"),
+			status: z.enum([
+				"backlog",
+				"in_progress",
+				"done",
+				"canceled"
+			]).optional().describe("Only items with this status; in_progress covers everything between backlog and done"),
+			planningStatus: z.enum([
+				"unplanned",
+				"planning",
+				"planned",
+				"failed"
+			]).optional().describe("Only items whose plan is in this state"),
+			category: z.enum([
+				"feature",
+				"bug",
+				"tech_debt",
+				"improvement"
+			]).optional().describe("Only this category"),
+			includeArchived: z.boolean().optional().describe("Include archived items (default false)"),
+			limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)")
+		},
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		return toolResult(pickFields((await client.listBacklogItems(params.productId, params)).data, BACKLOG_SUMMARY_FIELDS));
+	}));
+	server.registerTool("taiga_get_backlog_item", {
+		title: "Get backlog item",
+		description: "Get one backlog item in full: description, acceptance criteria (and which are met), technical context (patterns, constraints, references), dependencies and source documents. Read this before implementing an item, and read its runs with taiga_list_builds to see what the coding agent already did.",
+		inputSchema: { itemId: z.string().uuid().describe("Backlog item ID -- get from taiga_list_backlog_items") },
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		return toolResult((await client.getBacklogItem(params.itemId)).data);
+	}));
+}
+//#endregion
+//#region src/tools/builds.ts
+/** What a list row needs to say for the model to pick a run to read in full. */
+const BUILD_SUMMARY_FIELDS = [
+	"id",
+	"runNumber",
+	"backlogItemId",
+	"targetTitle",
+	"planId",
+	"status",
+	"failedReason",
+	"runtime",
+	"repositoryFullName",
+	"branch",
+	"baseBranch",
+	"completedSteps",
+	"totalSteps",
+	"prNumber",
+	"prUrl",
+	"prState",
+	"prDraft",
+	"prMerged",
+	"createdAt",
+	"startedAt",
+	"completedAt"
+];
+function registerBuildTools(server, client) {
+	if (!client.hasCapability("products:read")) return;
+	server.registerTool("taiga_list_builds", {
+		title: "List build runs",
+		description: "List the coding agent's runs for a product, newest first: status, branch, pull request and step progress. Use this to see what Taiga already built or is building, then read one run with taiga_get_build. Filter by backlog item to follow a single initiative.",
+		inputSchema: {
+			productId: z.string().uuid().describe("Product ID -- get from taiga_resolve_product (from a git remote) or taiga_list_products"),
+			backlogItemId: z.string().uuid().optional().describe("Only this backlog item's runs -- get from taiga_list_backlog_items"),
+			limit: z.number().int().min(1).max(100).optional().describe("Max results (default 25)")
+		},
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		return toolResult(pickFields((await client.listBuildRuns(params.productId, params)).data, BUILD_SUMMARY_FIELDS));
+	}));
+	server.registerTool("taiga_get_build", {
+		title: "Get build run",
+		description: "Get one run in full with its steps: what each step was meant to change, what it did change (commit, files), its status and any error. Use this to pick up where the coding agent stopped, or to understand the pull request it opened.",
+		inputSchema: { buildId: z.string().uuid().describe("Build run ID -- get from taiga_list_builds") },
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		const [run, steps] = await Promise.all([client.getBuildRun(params.buildId), client.listBuildRunSteps(params.buildId)]);
+		return toolResult({
+			...run.data,
+			steps: steps.data
+		});
+	}));
+}
+//#endregion
 //#region src/tools/index.ts
 /**
 * Register all MCP tools based on the API key's effective capabilities.
 * Only tools matching the key's scopes are registered -- the AI assistant
 * never sees tools it can't use.
-*
-* Beta scope: Knowledge base access (policies and factory instructions).
-* Post-beta: Products, backlog items, environments, composite tools.
 */
 function registerAllTools(server, client) {
 	registerProductTools(server, client);
 	registerDocumentTools(server, client);
+	registerBacklogTools(server, client);
+	registerBuildTools(server, client);
 }
 //#endregion
 //#region src/index.ts
@@ -633,9 +849,13 @@ async function main() {
 		"Specification (what to build), architecture (how it's designed), threat model (security risks),",
 		"technology decisions, and data flow. Read these to understand the specific product.",
 		"",
-		"Workflow: Start with taiga_list_factories to find your factory, then read its instructions.",
-		"For product-specific work, use taiga_list_products to find the product,",
-		"then read its specification and architecture.",
+		"**Backlog and runs** (taiga_list_backlog_items / taiga_get_backlog_item / taiga_list_builds / taiga_get_build):",
+		"The product's initiatives with their acceptance criteria, and what Taiga's coding agent already built",
+		"for them: runs, steps, commits and pull requests.",
+		"",
+		"Workflow: Inside a git checkout, start with taiga_resolve_product on the remote URL to find the product.",
+		"Otherwise use taiga_list_factories and taiga_list_products. Then read the factory instructions,",
+		"the product's specification and architecture, and the backlog item you are working on.",
 		"",
 		"When you notice a policy or factory instructions are outdated, fix the section with",
 		"taiga_update_document or taiga_update_factory_document. That saves a draft nobody follows yet;",

package/package.json

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

package/src/client.test.ts

@@ -144,14 +144,6 @@ describe('TaigaClient', () => {
       expect(url).toContain('/v1/products/proj-1/backlog');
       expect(url).toContain('limit=20');
     });
-
-    it('should nest environments under the product path', async () => {
-      const spy = stubFetch(200, { data: [] });
-
-      await makeClient().listEnvironments('proj-1');
-
-      expect(spy.mock.calls[0]![0]).toBe('https://api.test.com/v1/products/proj-1/environments');
-    });
   });
 
   // -------------------------------------------------------------------------
@@ -244,7 +236,7 @@ describe('TaigaClient', () => {
       await client.getFactoryDocument('f/1', 'a b');
       await client.getProduct('p/1');
       await client.getBacklogItem('b/1');
-      await client.listEnvironments('e/1');
+      await client.listBacklogItems('e/1');
       await client.getProductDocument('p/1', 'spec/x');
 
       const paths = spy.mock.calls.map((c) => new URL(c[0] as string).pathname);
@@ -253,7 +245,7 @@ describe('TaigaClient', () => {
         '/v1/factories/f%2F1/documents/a%20b',
         '/v1/products/p%2F1',
         '/v1/backlog/b%2F1',
-        '/v1/products/e%2F1/environments',
+        '/v1/products/e%2F1/backlog',
         '/v1/products/p%2F1/documents/spec%2Fx',
       ]);
     });
@@ -297,6 +289,55 @@ describe('TaigaClient', () => {
       });
     });
 
+    it('should send the backlog filters the route reads, with includeArchived as the literal true', async () => {
+      const spy = stubFetch(200, { data: [], nextCursor: null });
+
+      await makeClient().listBacklogItems('p1', { status: 'done', planningStatus: 'planned', includeArchived: true });
+
+      const url = new URL(spy.mock.calls[0]![0] as string);
+      expect(url.pathname).toBe('/v1/products/p1/backlog');
+      expect(url.searchParams.get('status')).toBe('done');
+      expect(url.searchParams.get('planningStatus')).toBe('planned');
+      expect(url.searchParams.get('includeArchived')).toBe('true');
+    });
+
+    it('should leave includeArchived out when false, since the route treats any value but true as false', async () => {
+      const spy = stubFetch(200, { data: [], nextCursor: null });
+
+      await makeClient().listBacklogItems('p1', { includeArchived: false });
+
+      expect(spy.mock.calls[0]![0]).toBe('https://api.test.com/v1/products/p1/backlog');
+    });
+
+    it('should GET runs under the product and a run with its steps by id', async () => {
+      const spy = stubFetch(200, { data: [] });
+      const client = makeClient();
+
+      await client.listBuildRuns('p1', { backlogItemId: 'i1', limit: 5 });
+      await client.getBuildRun('b/1');
+      await client.listBuildRunSteps('b/1');
+
+      const paths = spy.mock.calls.map((c) => {
+        const url = new URL(c[0] as string);
+        return url.pathname + url.search;
+      });
+      expect(paths).toEqual([
+        '/v1/products/p1/builds?backlogItemId=i1&limit=5',
+        '/v1/builds/b%2F1',
+        '/v1/builds/b%2F1/steps',
+      ]);
+    });
+
+    it('should send the repository filter and host when resolving a product', async () => {
+      const spy = stubFetch(200, { data: [], nextCursor: null });
+
+      await makeClient().listProducts({ repository: 'acme/web', repositoryHost: 'https://github.com' });
+
+      const url = new URL(spy.mock.calls[0]![0] as string);
+      expect(url.searchParams.get('repository')).toBe('acme/web');
+      expect(url.searchParams.get('repositoryHost')).toBe('https://github.com');
+    });
+
     it('should GET a single backlog item by id (flat path)', async () => {
       const spy = stubFetch(200, { data: { id: 'item-1' } });