@taiga-ai/mcp-server 0.3.0-dev.298 → 0.4.0-dev.299

package/dist/index.js

@@ -48,15 +48,15 @@ var TaigaClient = class {
 		if (!this.introspection) return false;
 		return this.introspection.capabilities.includes(capability);
 	}
-	async listProjects(opts) {
+	async listProducts(opts) {
 		const params = new URLSearchParams();
-		if (opts?.teamId) params.set("factoryId", opts.teamId);
+		if (opts?.factoryId) params.set("factoryId", opts.factoryId);
 		if (opts?.status) params.set("status", opts.status);
 		if (opts?.limit) params.set("limit", String(opts.limit));
 		const qs = params.toString();
 		return this.request("GET", `/products${qs ? `?${qs}` : ""}`);
 	}
-	async getProject(id) {
+	async getProduct(id) {
 		return this.request("GET", `/products/${id}`);
 	}
 	async listTenantDocuments(opts) {
@@ -71,103 +71,95 @@ var TaigaClient = class {
 	async saveTenantDocumentDraft(type, body) {
 		return this.request("PUT", `/tenants/current/documents/${type}/draft`, body);
 	}
-	async listTeamDocuments(teamId, opts) {
+	async listFactoryDocuments(factoryId, opts) {
 		const params = new URLSearchParams();
 		if (opts?.limit) params.set("limit", String(opts.limit));
 		const qs = params.toString();
-		return this.request("GET", `/factories/${teamId}/documents${qs ? `?${qs}` : ""}`);
+		return this.request("GET", `/factories/${factoryId}/documents${qs ? `?${qs}` : ""}`);
 	}
-	async getTeamDocument(teamId, type) {
-		return this.request("GET", `/factories/${teamId}/documents/${type}`);
+	async getFactoryDocument(factoryId, type) {
+		return this.request("GET", `/factories/${factoryId}/documents/${type}`);
 	}
-	async saveTeamDocumentDraft(teamId, type, body) {
-		return this.request("PUT", `/factories/${teamId}/documents/${type}/draft`, body);
+	async saveFactoryDocumentDraft(factoryId, type, body) {
+		return this.request("PUT", `/factories/${factoryId}/documents/${type}/draft`, body);
 	}
-	async listProjectDocuments(projectId, opts) {
+	async listProductDocuments(productId, opts) {
 		const params = new URLSearchParams();
 		if (opts?.limit) params.set("limit", String(opts.limit));
 		const qs = params.toString();
-		return this.request("GET", `/products/${projectId}/documents${qs ? `?${qs}` : ""}`);
+		return this.request("GET", `/products/${productId}/documents${qs ? `?${qs}` : ""}`);
 	}
-	async getProjectDocument(projectId, type) {
-		return this.request("GET", `/products/${projectId}/documents/${type}`);
+	async getProductDocument(productId, type) {
+		return this.request("GET", `/products/${productId}/documents/${type}`);
 	}
 	/**
-	* Fetch the full context for a project in parallel: project metadata,
-	* team documents and project documents.
+	* 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 getProjectContext(projectId) {
-		const project = await this.request("GET", `/products/${projectId}`);
-		const teamId = project.data.factoryId;
-		const [projectDocs, teamDocs] = await Promise.all([this.listProjectDocuments(projectId, { limit: 20 }).catch(() => ({ data: [] })), teamId ? this.listTeamDocuments(teamId, { limit: 20 }).catch(() => ({ data: [] })) : Promise.resolve({ data: [] })]);
-		const keyProjectDocTypes = [
+	async getProductContext(productId) {
+		const product = await this.request("GET", `/products/${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 keyTeamDocTypes = [
-			"domain_context",
-			"tech_preferences",
-			"architecture_constraints"
-		];
+		const keyFactoryDocTypes = ["team_instructions"];
 		const docFetches = [];
-		for (const docType of keyProjectDocTypes) if (projectDocs.data.some((d) => d.type === docType && !d.isDraft)) docFetches.push(this.getProjectDocument(projectId, docType).then((r) => ({
+		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: "project",
+			scope: "product",
 			data: r.data
 		})).catch(() => ({
 			type: docType,
-			scope: "project",
+			scope: "product",
 			data: null
 		})));
-		if (teamId) {
-			for (const docType of keyTeamDocTypes) if (teamDocs.data.some((d) => d.type === docType && !d.isDraft)) docFetches.push(this.getTeamDocument(teamId, docType).then((r) => ({
+		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: "team",
+				scope: "factory",
 				data: r.data
 			})).catch(() => ({
 				type: docType,
-				scope: "team",
+				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 {
-			project: project.data,
+			product: product.data,
 			documents: {
-				project: Object.fromEntries(fetchedDocs.filter((d) => d.scope === "project" && d.data).map((d) => [d.type, d.data])),
-				team: Object.fromEntries(fetchedDocs.filter((d) => d.scope === "team" && d.data).map((d) => [d.type, d.data]))
+				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: {
-				project: projectDocs.data.map((d) => ({
-					type: d.type,
-					name: d.name,
-					version: d.version,
-					isDraft: d.isDraft
-				})),
-				team: teamDocs.data.map((d) => ({
-					type: d.type,
-					name: d.name,
-					version: d.version,
-					isDraft: d.isDraft
-				}))
+				product: summarize(productDocs.data),
+				factory: summarize(factoryDocs.data)
 			}
 		};
 	}
-	async listBacklogItems(projectId, opts) {
+	async listBacklogItems(productId, opts) {
 		const params = new URLSearchParams();
 		if (opts?.limit) params.set("limit", String(opts.limit));
 		const qs = params.toString();
-		return this.request("GET", `/products/${projectId}/backlog${qs ? `?${qs}` : ""}`);
+		return this.request("GET", `/products/${productId}/backlog${qs ? `?${qs}` : ""}`);
 	}
 	async getBacklogItem(itemId) {
 		return this.request("GET", `/backlog/${itemId}`);
 	}
-	async listEnvironments(projectId) {
-		return this.request("GET", `/products/${projectId}/environments`);
+	async listEnvironments(productId) {
+		return this.request("GET", `/products/${productId}/environments`);
 	}
-	async listTeams(opts) {
+	async listFactories(opts) {
 		const params = new URLSearchParams();
 		if (opts?.limit) params.set("limit", String(opts.limit));
 		const qs = params.toString();
@@ -203,58 +195,58 @@ function summarizeList(items) {
 	});
 }
 //#endregion
-//#region src/tools/projects.ts
-function registerProjectTools(server, client) {
-	if (client.hasCapability("teams:read")) server.tool("taiga_list_teams", "List all teams in the organization. Use this to find team IDs for reading team documents and understanding team structure. Teams own domain context, tech preferences, and architecture constraints.", { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") }, {
+//#region src/tools/products.ts
+function registerProductTools(server, client) {
+	if (client.hasCapability("teams:read")) server.tool("taiga_list_factories", "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.", { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") }, {
 		readOnlyHint: true,
 		openWorldHint: false
 	}, async (params) => {
-		const result = await client.listTeams(params);
+		const result = await client.listFactories(params);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(result.data, null, 2)
 		}] };
 	});
 	if (client.hasCapability("projects:read")) {
-		server.tool("taiga_list_projects", "List projects in the organization. Use this to find the project you are working on so you can read its specification, architecture, and threat model. Can filter by team; a status filter also exists but no longer distinguishes anything (see its description).", {
-			teamId: z.string().uuid().optional().describe("Filter by team ID -- get team IDs from taiga_list_teams"),
+		server.tool("taiga_list_products", "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).", {
+			factoryId: z.string().uuid().optional().describe("Filter by factory ID -- get factory IDs from taiga_list_factories"),
 			status: z.enum([
 				"draft",
 				"active",
 				"archived"
-			]).optional().describe("Filter by status. Taiga no longer surfaces project status in its UI (PRO-543), so every project is currently \"draft\" and filtering by \"active\" or \"archived\" returns nothing. Omit this unless you are working with data set through the API directly."),
+			]).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)")
 		}, {
 			readOnlyHint: true,
 			openWorldHint: false
 		}, async (params) => {
-			const result = await client.listProjects(params);
+			const result = await client.listProducts(params);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(result.data, null, 2)
 			}] };
 		});
-		server.tool("taiga_list_project_documents", "List documents for a specific project (names and types only). Project documents are generated during intake: specification (requirements), architecture (system design), technology decisions, data flow, privacy assessment, threat model (security risks), risk register, and user flow. Use taiga_get_project_document to read the full content.", {
-			projectId: z.string().uuid().describe("Project ID -- get from taiga_list_projects"),
+		server.tool("taiga_list_product_documents", "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.", {
+			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)")
 		}, {
 			readOnlyHint: true,
 			openWorldHint: false
 		}, async (params) => {
-			const summaries = summarizeList((await client.listProjectDocuments(params.projectId, { limit: params.limit })).data);
+			const summaries = summarizeList((await client.listProductDocuments(params.productId, { limit: params.limit })).data);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(summaries, null, 2)
 			}] };
 		});
-		server.tool("taiga_get_project_document", "Get the full content of a specific project document. Use this when you need to understand what to build (specification), how the system is designed (architecture), what security risks exist (threat model), or what technology choices were made (technology_decisions). Types: specification, architecture, technology_decisions, data_flow, privacy_assessment, threat_model, risk_register, user_flow.", {
-			projectId: z.string().uuid().describe("Project ID -- get from taiga_list_projects"),
-			type: z.string().describe("Document type -- get available types from taiga_list_project_documents. Common: specification, architecture, threat_model, technology_decisions")
+		server.tool("taiga_get_product_document", "Get the full content of a specific product document. Use this when you need to understand what to build (specification), how the system is designed (architecture), what security risks exist (threat model), or what technology choices were made (technology_decisions). Types: specification, architecture, technology_decisions, data_flow, privacy_assessment, threat_model, risk_register, user_flow, service_blueprint, ui_direction, codebase_snapshot. The product instructions document is `project_instructions` (its stored type keeps the old name).", {
+			productId: z.string().uuid().describe("Product ID -- get from taiga_list_products"),
+			type: z.string().describe("Document type -- get available types from taiga_list_product_documents. Common: specification, architecture, threat_model, technology_decisions")
 		}, {
 			readOnlyHint: true,
 			openWorldHint: false
 		}, async (params) => {
-			const result = await client.getProjectDocument(params.projectId, params.type);
+			const result = await client.getProductDocument(params.productId, params.type);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(result.data, null, 2)
@@ -266,7 +258,7 @@ function registerProjectTools(server, client) {
 //#region src/tools/documents.ts
 function registerDocumentTools(server, client) {
 	if (client.hasCapability("tenant:documents:read")) {
-		server.tool("taiga_list_documents", "List company-level policy documents (names and types only). Policies define security, data privacy, SDLC, operations, architecture, and compliance rules that apply across all teams and projects. Use taiga_get_document with the document type to read the full policy content.", { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") }, {
+		server.tool("taiga_list_documents", "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.", { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") }, {
 			readOnlyHint: true,
 			openWorldHint: false
 		}, async (params) => {
@@ -304,36 +296,36 @@ function registerDocumentTools(server, client) {
 		}] };
 	});
 	if (client.hasCapability("teams:read")) {
-		server.tool("taiga_list_team_documents", "List documents for a specific team (names and types only). Team documents define how the team works: domain context (entities, ubiquitous language), tech preferences (approved stack), architecture constraints, SLO targets, definition of done, and team charter. Use taiga_get_team_document to read the full content.", {
-			teamId: z.string().uuid().describe("Team ID -- get from taiga_list_teams"),
+		server.tool("taiga_list_factory_documents", "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.", {
+			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)")
 		}, {
 			readOnlyHint: true,
 			openWorldHint: false
 		}, async (params) => {
-			const summaries = summarizeList((await client.listTeamDocuments(params.teamId, { limit: params.limit })).data);
+			const summaries = summarizeList((await client.listFactoryDocuments(params.factoryId, { limit: params.limit })).data);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(summaries, null, 2)
 			}] };
 		});
-		server.tool("taiga_get_team_document", "Get the full content of a specific team document. Use this when you need the team domain context (ubiquitous language, entities, business rules), tech preferences (approved stack, patterns), or architecture constraints. Types: team_charter, definition_of_done, tech_preferences, architecture_constraints, slo_targets, domain_context.", {
-			teamId: z.string().uuid().describe("Team ID -- get from taiga_list_teams"),
-			type: z.string().describe("Document type -- get available types from taiga_list_team_documents. Most useful: domain_context (entities, language), tech_preferences (stack, patterns)")
+		server.tool("taiga_get_factory_document", "Get the full content of a factory's instructions. Use this when you need the domain context, tech preferences, or conventions the factory expects every product it owns to follow.", {
+			factoryId: z.string().uuid().describe("Factory ID -- get from taiga_list_factories"),
+			type: z.string().describe("Document type -- get available types from taiga_list_factory_documents. The factory instructions document is `team_instructions` (its stored type keeps the old name).")
 		}, {
 			readOnlyHint: true,
 			openWorldHint: false
 		}, async (params) => {
-			const result = await client.getTeamDocument(params.teamId, params.type);
+			const result = await client.getFactoryDocument(params.factoryId, params.type);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(result.data, null, 2)
 			}] };
 		});
 	}
-	if (client.hasCapability("teams:read") && client.hasCapability("tenant:documents:write")) server.tool("taiga_update_team_document", "Update the draft content of a team document. Only updates the draft -- does not publish. Use this when you notice team conventions, domain context, or tech preferences need updating while working on the codebase.", {
-		teamId: z.string().uuid().describe("Team ID -- get from taiga_list_teams"),
-		type: z.string().describe("Document type (e.g. domain_context, tech_preferences)"),
+	if (client.hasCapability("teams:read") && client.hasCapability("tenant:documents:write")) server.tool("taiga_update_factory_document", "Update the draft of a factory's instructions. Only updates the draft -- does not publish. Use this when you notice the factory conventions, domain context, or tech preferences need updating while working on the codebase.", {
+		factoryId: z.string().uuid().describe("Factory ID -- get from taiga_list_factories"),
+		type: z.string().describe("Document type (`team_instructions`)"),
 		data: z.record(z.string(), z.unknown()).describe("Document content to save as JSON")
 	}, {
 		readOnlyHint: false,
@@ -341,8 +333,8 @@ function registerDocumentTools(server, client) {
 		idempotentHint: true,
 		openWorldHint: false
 	}, async (params) => {
-		const { teamId, type, ...body } = params;
-		const result = await client.saveTeamDocumentDraft(teamId, type, body);
+		const { factoryId, type, ...body } = params;
+		const result = await client.saveFactoryDocumentDraft(factoryId, type, body);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(result.data, null, 2)
@@ -356,11 +348,11 @@ function registerDocumentTools(server, client) {
 * 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 team documents).
-* Post-beta: Projects, backlog items, environments, composite tools.
+* Beta scope: Knowledge base access (policies and factory instructions).
+* Post-beta: Products, backlog items, environments, composite tools.
 */
 function registerAllTools(server, client) {
-	registerProjectTools(server, client);
+	registerProductTools(server, client);
 	registerDocumentTools(server, client);
 }
 //#endregion
@@ -394,20 +386,20 @@ async function main() {
 		"Security, data privacy, SDLC, architecture, and compliance rules that apply to all code.",
 		"Read the relevant policy BEFORE writing code that touches security, data handling, or infrastructure.",
 		"",
-		"**Team documents** (taiga_list_team_documents / taiga_get_team_document):",
-		"Domain context (ubiquitous language, entities, business rules), tech preferences (approved stack, patterns),",
-		"architecture constraints, and SLO targets. Read these to understand HOW this team builds software.",
+		"**Factory instructions** (taiga_list_factory_documents / taiga_get_factory_document):",
+		"A factory's standing guidance: domain context (ubiquitous language, entities, business rules),",
+		"tech preferences (approved stack, patterns), and conventions. Read these to understand HOW this factory builds software.",
 		"",
-		"**Project documents** (taiga_list_project_documents / taiga_get_project_document):",
+		"**Product documents** (taiga_list_product_documents / taiga_get_product_document):",
 		"Specification (what to build), architecture (how it's designed), threat model (security risks),",
-		"technology decisions, and data flow. Read these to understand the specific project context.",
+		"technology decisions, and data flow. Read these to understand the specific product.",
 		"",
-		"Workflow: Start with taiga_list_teams to find your team, then read the team's domain_context",
-		"and tech_preferences. For project-specific work, use taiga_list_projects to find the project,",
+		"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.",
 		"",
-		"When you notice a policy or team document is outdated, use the update tools",
-		"(taiga_update_document, taiga_update_team_document) to fix it.",
+		"When you notice a policy or factory instructions are outdated, use the update tools",
+		"(taiga_update_document, taiga_update_factory_document) to fix it.",
 		"This keeps the knowledge base accurate for everyone."
 	].join("\n") });
 	registerAllTools(server, client);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.3.0-dev.298",
-  "description": "MCP server for Taiga -- gives AI assistants access to documents and projects",
+  "version": "0.4.0-dev.299",
+  "description": "MCP server for Taiga -- gives AI assistants access to documents and products",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {

package/src/client.test.ts

@@ -54,7 +54,7 @@ describe('TaigaClient', () => {
       const client = makeClient({ apiKey: 'taiga_sk_live_secret42' });
 
       // Act
-      await client.listProjects();
+      await client.listProducts();
 
       // Assert
       const headers = spy.mock.calls[0][1].headers;
@@ -64,7 +64,7 @@ describe('TaigaClient', () => {
     it('should identify itself as taiga-ai-mcp-server in every request', async () => {
       const spy = stubFetch(200, { data: [] });
 
-      await makeClient().listProjects();
+      await makeClient().listProducts();
 
       expect(spy.mock.calls[0][1].headers['User-Agent']).toBe(`taiga-ai-mcp-server/${pkg.version}`);
     });
@@ -79,7 +79,7 @@ describe('TaigaClient', () => {
       stubFetch(403, { error: 'Forbidden' });
       const client = makeClient();
 
-      await expect(client.listProjects()).rejects.toThrow(/403.*Forbidden/);
+      await expect(client.listProducts()).rejects.toThrow(/403.*Forbidden/);
     });
 
     it('should reject with status code even when response body is unreadable', async () => {
@@ -92,13 +92,13 @@ describe('TaigaClient', () => {
         })
       );
 
-      await expect(makeClient().listProjects()).rejects.toThrow(/500/);
+      await expect(makeClient().listProducts()).rejects.toThrow(/500/);
     });
 
     it('should reject when fetch itself throws (network failure)', async () => {
       vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
 
-      await expect(makeClient().listProjects()).rejects.toThrow(/ECONNREFUSED/);
+      await expect(makeClient().listProducts()).rejects.toThrow(/ECONNREFUSED/);
     });
   });
 
@@ -111,7 +111,7 @@ describe('TaigaClient', () => {
       const spy = stubFetch(200, { data: [] });
       const client = makeClient({ baseUrl: 'https://api.test.com///' });
 
-      await client.listProjects();
+      await client.listProducts();
 
       expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products');
     });
@@ -119,7 +119,7 @@ describe('TaigaClient', () => {
     it('should omit query string when no optional params are provided', async () => {
       const spy = stubFetch(200, { data: [], nextCursor: null });
 
-      await makeClient().listProjects();
+      await makeClient().listProducts();
 
       expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products');
     });
@@ -127,7 +127,7 @@ describe('TaigaClient', () => {
     it('should include all optional filters as query params', async () => {
       const spy = stubFetch(200, { data: [], nextCursor: null });
 
-      await makeClient().listProjects({ teamId: 't1', status: 'active', limit: 10 });
+      await makeClient().listProducts({ factoryId: 't1', status: 'active', limit: 10 });
 
       const url = spy.mock.calls[0][0] as string;
       expect(url).toContain('factoryId=t1');
@@ -135,7 +135,7 @@ describe('TaigaClient', () => {
       expect(url).toContain('limit=10');
     });
 
-    it('should nest backlog items under the project path', async () => {
+    it('should nest backlog items under the product path', async () => {
       const spy = stubFetch(200, { data: [], nextCursor: null });
 
       await makeClient().listBacklogItems('proj-1', { limit: 20 });
@@ -145,7 +145,7 @@ describe('TaigaClient', () => {
       expect(url).toContain('limit=20');
     });
 
-    it('should nest environments under the project path', async () => {
+    it('should nest environments under the product path', async () => {
       const spy = stubFetch(200, { data: [] });
 
       await makeClient().listEnvironments('proj-1');
@@ -206,10 +206,10 @@ describe('TaigaClient', () => {
   // -------------------------------------------------------------------------
 
   describe('API contracts', () => {
-    it('should GET a single project by id', async () => {
+    it('should GET a single product by id', async () => {
       const spy = stubFetch(200, { data: { id: 'p1', name: 'Alpha' } });
 
-      const result = await makeClient().getProject('p1');
+      const result = await makeClient().getProduct('p1');
 
       expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products/p1');
       expect(result.data).toEqual({ id: 'p1', name: 'Alpha' });
@@ -243,10 +243,10 @@ describe('TaigaClient', () => {
       expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/backlog/item-1');
     });
 
-    it('should GET teams with optional limit', async () => {
+    it('should GET factories with optional limit', async () => {
       const spy = stubFetch(200, { data: [], nextCursor: null });
 
-      await makeClient().listTeams({ limit: 50 });
+      await makeClient().listFactories({ limit: 50 });
 
       expect(spy.mock.calls[0][0]).toContain('/v1/factories?limit=50');
     });

package/src/client.ts

@@ -57,19 +57,19 @@ export class TaigaClient {
   }
 
   // ---------------------------------------------------------------------------
-  // Projects
+  // Products
   // ---------------------------------------------------------------------------
 
-  async listProjects(opts?: { teamId?: string; status?: string; limit?: number }) {
+  async listProducts(opts?: { factoryId?: string; status?: string; limit?: number }) {
     const params = new URLSearchParams();
-    if (opts?.teamId) params.set('factoryId', opts.teamId);
+    if (opts?.factoryId) params.set('factoryId', opts.factoryId);
     if (opts?.status) params.set('status', opts.status);
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/products${qs ? `?${qs}` : ''}`);
   }
 
-  async getProject(id: string) {
+  async getProduct(id: string) {
     return this.request<{ data: unknown }>('GET', `/products/${id}`);
   }
 
@@ -96,138 +96,131 @@ export class TaigaClient {
   }
 
   // ---------------------------------------------------------------------------
-  // Team Documents
+  // Factory Documents
   // ---------------------------------------------------------------------------
 
-  async listTeamDocuments(teamId: string, opts?: { limit?: number }) {
+  async listFactoryDocuments(factoryId: string, opts?: { limit?: number }) {
     const params = new URLSearchParams();
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>(
       'GET',
-      `/factories/${teamId}/documents${qs ? `?${qs}` : ''}`
+      `/factories/${factoryId}/documents${qs ? `?${qs}` : ''}`
     );
   }
 
-  async getTeamDocument(teamId: string, type: string) {
-    return this.request<{ data: unknown }>('GET', `/factories/${teamId}/documents/${type}`);
+  async getFactoryDocument(factoryId: string, type: string) {
+    return this.request<{ data: unknown }>('GET', `/factories/${factoryId}/documents/${type}`);
   }
 
-  async saveTeamDocumentDraft(teamId: string, type: string, body: { data: Record<string, unknown> }) {
-    return this.request<{ data: unknown }>('PUT', `/factories/${teamId}/documents/${type}/draft`, body);
+  async saveFactoryDocumentDraft(factoryId: string, type: string, body: { data: Record<string, unknown> }) {
+    return this.request<{ data: unknown }>('PUT', `/factories/${factoryId}/documents/${type}/draft`, body);
   }
 
   // ---------------------------------------------------------------------------
-  // Project Documents
+  // Product Documents
   // ---------------------------------------------------------------------------
 
-  async listProjectDocuments(projectId: string, opts?: { limit?: number }) {
+  async listProductDocuments(productId: string, opts?: { limit?: number }) {
     const params = new URLSearchParams();
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>(
       'GET',
-      `/products/${projectId}/documents${qs ? `?${qs}` : ''}`
+      `/products/${productId}/documents${qs ? `?${qs}` : ''}`
     );
   }
 
-  async getProjectDocument(projectId: string, type: string) {
-    return this.request<{ data: unknown }>('GET', `/products/${projectId}/documents/${type}`);
+  async getProductDocument(productId: string, type: string) {
+    return this.request<{ data: unknown }>('GET', `/products/${productId}/documents/${type}`);
   }
 
   // ---------------------------------------------------------------------------
-  // Team Documents
+  // Factory Documents
   // ---------------------------------------------------------------------------
 
   /**
-   * Fetch the full context for a project in parallel: project metadata,
-   * team documents and project documents.
+   * 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 getProjectContext(projectId: string): Promise<Record<string, unknown>> {
-    // First fetch the project to get its factory (the API's name for a team since PRO-1668)
-    const project = await this.request<{ data: Record<string, unknown> }>('GET', `/products/${projectId}`);
-    const teamId = project.data.factoryId as string | undefined;
+  async getProductContext(productId: string): Promise<Record<string, unknown>> {
+    // First fetch the product to get its factory
+    const product = await this.request<{ data: Record<string, unknown> }>('GET', `/products/${productId}`);
+    const factoryId = product.data.factoryId as string | undefined;
 
     // Fetch the document lists in parallel.
-    const [projectDocs, teamDocs] = await Promise.all([
-      this.listProjectDocuments(projectId, { limit: 20 }).catch(() => ({ data: [] })),
-      teamId
-        ? this.listTeamDocuments(teamId, { limit: 20 }).catch(() => ({ data: [] }))
+    const [productDocs, factoryDocs] = await Promise.all([
+      this.listProductDocuments(productId, { limit: 20 }).catch(() => ({ data: [] })),
+      factoryId
+        ? this.listFactoryDocuments(factoryId, { limit: 20 }).catch(() => ({ data: [] }))
         : Promise.resolve({ data: [] }),
     ]);
 
     // Fetch full content for key documents (in parallel)
-    const keyProjectDocTypes = ['specification', 'architecture', 'technology_decisions'];
-    const keyTeamDocTypes = ['domain_context', 'tech_preferences', 'architecture_constraints'];
+    const keyProductDocTypes = ['specification', 'architecture', 'technology_decisions'];
+    // The factory instructions document; its stored type keeps the old name until PRO-1671.
+    const keyFactoryDocTypes = ['team_instructions'];
 
     const docFetches: Promise<{ type: string; scope: string; data: unknown }>[] = [];
 
-    for (const docType of keyProjectDocTypes) {
-      const exists = (projectDocs.data as Record<string, unknown>[]).some((d) => d.type === docType && !d.isDraft);
+    for (const docType of keyProductDocTypes) {
+      const exists = (productDocs.data as Record<string, unknown>[]).some((d) => d.type === docType && !d.isDraft);
       if (exists) {
         docFetches.push(
-          this.getProjectDocument(projectId, docType)
-            .then((r) => ({ type: docType, scope: 'project', data: r.data }))
-            .catch(() => ({ type: docType, scope: 'project', data: null }))
+          this.getProductDocument(productId, docType)
+            .then((r) => ({ type: docType, scope: 'product', data: r.data }))
+            .catch(() => ({ type: docType, scope: 'product', data: null }))
         );
       }
     }
 
-    if (teamId) {
-      for (const docType of keyTeamDocTypes) {
-        const exists = (teamDocs.data as Record<string, unknown>[]).some((d) => d.type === docType && !d.isDraft);
+    if (factoryId) {
+      for (const docType of keyFactoryDocTypes) {
+        const exists = (factoryDocs.data as Record<string, unknown>[]).some((d) => d.type === docType && !d.isDraft);
         if (exists) {
           docFetches.push(
-            this.getTeamDocument(teamId, docType)
-              .then((r) => ({ type: docType, scope: 'team', data: r.data }))
-              .catch(() => ({ type: docType, scope: 'team', data: null }))
+            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: Record<string, unknown>[]) =>
+      docs.map((d) => ({ type: d.type, name: d.name, version: d.version, isDraft: d.isDraft }));
 
     // Assemble context bundle
-    const context: Record<string, unknown> = {
-      project: project.data,
+    return {
+      product: product.data,
       documents: {
-        project: Object.fromEntries(
-          fetchedDocs.filter((d) => d.scope === 'project' && d.data).map((d) => [d.type, d.data])
+        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])
         ),
-        team: Object.fromEntries(fetchedDocs.filter((d) => d.scope === 'team' && d.data).map((d) => [d.type, d.data])),
       },
       available_documents: {
-        project: (projectDocs.data as Record<string, unknown>[]).map((d) => ({
-          type: d.type,
-          name: d.name,
-          version: d.version,
-          isDraft: d.isDraft,
-        })),
-        team: (teamDocs.data as Record<string, unknown>[]).map((d) => ({
-          type: d.type,
-          name: d.name,
-          version: d.version,
-          isDraft: d.isDraft,
-        })),
+        product: summarize(productDocs.data as Record<string, unknown>[]),
+        factory: summarize(factoryDocs.data as Record<string, unknown>[]),
       },
     };
-
-    return context;
   }
 
   // ---------------------------------------------------------------------------
   // Backlog
   // ---------------------------------------------------------------------------
 
-  async listBacklogItems(projectId: string, opts?: { limit?: number }) {
+  async listBacklogItems(productId: string, opts?: { limit?: number }) {
     const params = new URLSearchParams();
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>(
       'GET',
-      `/products/${projectId}/backlog${qs ? `?${qs}` : ''}`
+      `/products/${productId}/backlog${qs ? `?${qs}` : ''}`
     );
   }
 
@@ -239,15 +232,15 @@ export class TaigaClient {
   // Environments
   // ---------------------------------------------------------------------------
 
-  async listEnvironments(projectId: string) {
-    return this.request<{ data: unknown[] }>('GET', `/products/${projectId}/environments`);
+  async listEnvironments(productId: string) {
+    return this.request<{ data: unknown[] }>('GET', `/products/${productId}/environments`);
   }
 
   // ---------------------------------------------------------------------------
-  // Teams
+  // Factories
   // ---------------------------------------------------------------------------
 
-  async listTeams(opts?: { limit?: number }) {
+  async listFactories(opts?: { limit?: number }) {
     const params = new URLSearchParams();
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();

package/src/index.ts

@@ -43,20 +43,20 @@ async function main() {
         'Security, data privacy, SDLC, architecture, and compliance rules that apply to all code.',
         'Read the relevant policy BEFORE writing code that touches security, data handling, or infrastructure.',
         '',
-        '**Team documents** (taiga_list_team_documents / taiga_get_team_document):',
-        'Domain context (ubiquitous language, entities, business rules), tech preferences (approved stack, patterns),',
-        'architecture constraints, and SLO targets. Read these to understand HOW this team builds software.',
+        '**Factory instructions** (taiga_list_factory_documents / taiga_get_factory_document):',
+        "A factory's standing guidance: domain context (ubiquitous language, entities, business rules),",
+        'tech preferences (approved stack, patterns), and conventions. Read these to understand HOW this factory builds software.',
         '',
-        '**Project documents** (taiga_list_project_documents / taiga_get_project_document):',
+        '**Product documents** (taiga_list_product_documents / taiga_get_product_document):',
         "Specification (what to build), architecture (how it's designed), threat model (security risks),",
-        'technology decisions, and data flow. Read these to understand the specific project context.',
+        'technology decisions, and data flow. Read these to understand the specific product.',
         '',
-        "Workflow: Start with taiga_list_teams to find your team, then read the team's domain_context",
-        'and tech_preferences. For project-specific work, use taiga_list_projects to find the project,',
+        '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.',
         '',
-        'When you notice a policy or team document is outdated, use the update tools',
-        '(taiga_update_document, taiga_update_team_document) to fix it.',
+        'When you notice a policy or factory instructions are outdated, use the update tools',
+        '(taiga_update_document, taiga_update_factory_document) to fix it.',
         'This keeps the knowledge base accurate for everyone.',
       ].join('\n'),
     }

package/src/server.integration.test.ts

@@ -24,15 +24,15 @@ const ALL_CAPABILITIES = [
  */
 const ALL_TOOL_NAMES = [
   'taiga_get_document',
-  'taiga_get_project_document',
-  'taiga_get_team_document',
+  'taiga_get_factory_document',
+  'taiga_get_product_document',
   'taiga_list_documents',
-  'taiga_list_project_documents',
-  'taiga_list_projects',
-  'taiga_list_team_documents',
-  'taiga_list_teams',
+  'taiga_list_factories',
+  'taiga_list_factory_documents',
+  'taiga_list_product_documents',
+  'taiga_list_products',
   'taiga_update_document',
-  'taiga_update_team_document',
+  'taiga_update_factory_document',
 ];
 
 function makeFetchRouter(routes: Record<string, unknown>) {
@@ -146,15 +146,15 @@ describe('MCP server integration', () => {
       await expect(client.listTools()).rejects.toThrow(/Method not found/);
     });
 
-    it('should expose only team tools for a teams:read-only key', async () => {
+    it('should expose only factory tools for a teams:read-only key', async () => {
       const { client } = await bootMcpPair({ capabilities: ['teams:read'] });
 
       const { tools } = await client.listTools();
       const names = toolNames(tools);
 
-      expect(names).toContain('taiga_list_teams');
-      expect(names).toContain('taiga_list_team_documents');
-      expect(names).toContain('taiga_get_team_document');
+      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');
     });
@@ -181,7 +181,7 @@ describe('MCP server integration', () => {
       expect(names).toContain('taiga_update_document');
     });
 
-    it('should expose team document write when both teams:read and documents:write are granted', async () => {
+    it('should expose factory document write when both teams:read and documents:write are granted', async () => {
       const { client } = await bootMcpPair({
         capabilities: ['teams:read', 'tenant:documents:write'],
       });
@@ -189,8 +189,8 @@ describe('MCP server integration', () => {
       const { tools } = await client.listTools();
       const names = toolNames(tools);
 
-      expect(names).toContain('taiga_update_team_document');
-      expect(names).toContain('taiga_list_teams');
+      expect(names).toContain('taiga_update_factory_document');
+      expect(names).toContain('taiga_list_factories');
     });
 
     it('should combine capabilities additively', async () => {
@@ -202,8 +202,8 @@ describe('MCP server integration', () => {
       const names = toolNames(tools);
 
       // teams:read tools present
-      expect(names).toContain('taiga_list_teams');
-      expect(names).toContain('taiga_list_team_documents');
+      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
@@ -231,8 +231,8 @@ describe('MCP server integration', () => {
 
   describe('capability-tool contract', () => {
     const CONTRACT: Record<string, string[]> = {
-      'projects:read': ['taiga_list_projects', 'taiga_list_project_documents', 'taiga_get_project_document'],
-      'teams:read': ['taiga_list_teams', 'taiga_list_team_documents', 'taiga_get_team_document'],
+      'projects:read': ['taiga_list_products', 'taiga_list_product_documents', 'taiga_get_product_document'],
+      'teams:read': ['taiga_list_factories', 'taiga_list_factory_documents', 'taiga_get_factory_document'],
       'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document'],
       'tenant:documents:write': ['taiga_update_document'],
     };
@@ -258,21 +258,21 @@ describe('MCP server integration', () => {
   // -------------------------------------------------------------------------
 
   describe('tool execution', () => {
-    it('should return team list as JSON text content', async () => {
-      const teams = [
+    it('should return factory list as JSON text content', async () => {
+      const factories = [
         { id: 't1', name: 'Product' },
         { id: 't2', name: 'Platform' },
       ];
 
       const { client } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/factories': { data: teams, nextCursor: null } },
+        routes: { 'GET /v1/factories': { data: factories, nextCursor: null } },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_list_factories', arguments: {} });
 
       expect(result.content).toHaveLength(1);
-      expect(parseToolResult(result)).toEqual(teams);
+      expect(parseToolResult(result)).toEqual(factories);
     });
 
     it('should return document content through MCP protocol', async () => {
@@ -307,39 +307,39 @@ describe('MCP server integration', () => {
       expect(putCall![0]).toContain(`/v1/tenants/current/documents/${docType}/draft`);
     });
 
-    it('should send PUT when updating a team document draft', async () => {
-      const teamId = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b';
+    it('should send PUT when updating a factory document draft', async () => {
+      const factoryId = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b';
       const docType = 'domain_context';
       const updated = { type: docType, name: 'Domain Context' };
 
       const { client, fetchSpy } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { [`PUT /v1/factories/${teamId}/documents/${docType}/draft`]: { data: updated } },
+        routes: { [`PUT /v1/factories/${factoryId}/documents/${docType}/draft`]: { data: updated } },
       });
 
       await client.callTool({
-        name: 'taiga_update_team_document',
-        arguments: { teamId, type: docType, data: { sections: { overview: 'Updated' } } },
+        name: 'taiga_update_factory_document',
+        arguments: { factoryId, type: docType, data: { sections: { overview: 'Updated' } } },
       });
 
       const putCall = fetchSpy.mock.calls.find(
         (c: unknown[]) => (c[1] as RequestInit)?.method === 'PUT' && (c[0] as string).includes('/factories/')
       );
       expect(putCall).toBeDefined();
-      expect(putCall![0]).toContain(`/v1/factories/${teamId}/documents/${docType}/draft`);
+      expect(putCall![0]).toContain(`/v1/factories/${factoryId}/documents/${docType}/draft`);
     });
 
-    it('should return teams through MCP protocol', async () => {
-      const teams = [{ id: 't1', name: 'Engineering' }];
+    it('should return factories through MCP protocol', async () => {
+      const factories = [{ id: 't1', name: 'Engineering' }];
 
       const { client } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/factories': { data: teams, nextCursor: null } },
+        routes: { 'GET /v1/factories': { data: factories, nextCursor: null } },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_list_factories', arguments: {} });
 
-      expect(parseToolResult(result)).toEqual(teams);
+      expect(parseToolResult(result)).toEqual(factories);
     });
   });
 
@@ -380,7 +380,7 @@ describe('MCP server integration', () => {
       await Promise.all([server.connect(st), mcpClient.connect(ct)]);
 
       // Act
-      const result = await mcpClient.callTool({ name: 'taiga_list_projects', arguments: {} });
+      const result = await mcpClient.callTool({ name: 'taiga_list_products', arguments: {} });
 
       // Assert -- the MCP SDK marks tool errors with isError
       expect(result.isError).toBe(true);
@@ -392,9 +392,9 @@ describe('MCP server integration', () => {
         routes: {},
       });
 
-      // taiga_get_project requires a UUID, not a plain string
+      // taiga_get_product requires a UUID, not a plain string
       const result = await client.callTool({
-        name: 'taiga_get_project',
+        name: 'taiga_get_product',
         arguments: { id: 'not-a-uuid' },
       });
 

package/src/tools/backlogs.ts

@@ -1,5 +1,5 @@
 // Backlog tools are reserved for post-beta.
-// The beta MCP server focuses on the knowledge base (policies, team docs).
+// The beta MCP server focuses on the knowledge base (policies, factory instructions).
 
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TaigaClient } from '../client.js';

package/src/tools/documents.ts

@@ -11,7 +11,7 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
       'taiga_list_documents',
       'List company-level policy documents (names and types only). ' +
         'Policies define security, data privacy, SDLC, operations, architecture, and compliance rules ' +
-        'that apply across all teams and projects. ' +
+        'that apply across all factories and products. ' +
         'Use taiga_get_document with the document type to read the full policy content.',
       {
         limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
@@ -72,23 +72,23 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
     );
   }
 
-  // ── Team documents ──────────────────────────────────────────────────
+  // ── Factory instructions ────────────────────────────────────────────
+  // Capability strings still say teams until the database rename (PRO-1671).
 
   if (client.hasCapability('teams:read')) {
     server.tool(
-      'taiga_list_team_documents',
-      'List documents for a specific team (names and types only). ' +
-        'Team documents define how the team works: domain context (entities, ubiquitous language), ' +
-        'tech preferences (approved stack), architecture constraints, SLO targets, ' +
-        'definition of done, and team charter. ' +
-        'Use taiga_get_team_document to read the full content.',
+      'taiga_list_factory_documents',
+      '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.',
       {
-        teamId: z.string().uuid().describe('Team ID -- get from taiga_list_teams'),
+        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)'),
       },
       { readOnlyHint: true, openWorldHint: false },
       async (params) => {
-        const result = await client.listTeamDocuments(params.teamId, { limit: params.limit });
+        const result = await client.listFactoryDocuments(params.factoryId, { limit: params.limit });
         const summaries = summarizeList(result.data as Record<string, unknown>[]);
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(summaries, null, 2) }],
@@ -97,24 +97,22 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
     );
 
     server.tool(
-      'taiga_get_team_document',
-      'Get the full content of a specific team document. ' +
-        'Use this when you need the team domain context (ubiquitous language, entities, business rules), ' +
-        'tech preferences (approved stack, patterns), or architecture constraints. ' +
-        'Types: team_charter, definition_of_done, tech_preferences, ' +
-        'architecture_constraints, slo_targets, domain_context.',
+      'taiga_get_factory_document',
+      "Get the full content of a factory's instructions. " +
+        'Use this when you need the domain context, tech preferences, or conventions ' +
+        'the factory expects every product it owns to follow.',
       {
-        teamId: z.string().uuid().describe('Team ID -- get from taiga_list_teams'),
+        factoryId: z.string().uuid().describe('Factory ID -- get from taiga_list_factories'),
         type: z
           .string()
           .describe(
-            'Document type -- get available types from taiga_list_team_documents. ' +
-              'Most useful: domain_context (entities, language), tech_preferences (stack, patterns)'
+            'Document type -- get available types from taiga_list_factory_documents. ' +
+              'The factory instructions document is `team_instructions` (its stored type keeps the old name).'
           ),
       },
       { readOnlyHint: true, openWorldHint: false },
       async (params) => {
-        const result = await client.getTeamDocument(params.teamId, params.type);
+        const result = await client.getFactoryDocument(params.factoryId, params.type);
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
         };
@@ -122,22 +120,26 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
     );
   }
 
-  // Team document write requires both teams:read (to find the team) and tenant:documents:write
+  // Factory document write requires both teams:read (to find the factory) and tenant:documents:write
   if (client.hasCapability('teams:read') && client.hasCapability('tenant:documents:write')) {
     server.tool(
-      'taiga_update_team_document',
-      'Update the draft content of a team document. ' +
-        'Only updates the draft -- does not publish. Use this when you notice team conventions, ' +
+      'taiga_update_factory_document',
+      "Update the draft of a factory's instructions. " +
+        'Only updates the draft -- does not publish. Use this when you notice the factory conventions, ' +
         'domain context, or tech preferences need updating while working on the codebase.',
       {
-        teamId: z.string().uuid().describe('Team ID -- get from taiga_list_teams'),
-        type: z.string().describe('Document type (e.g. domain_context, tech_preferences)'),
+        factoryId: z.string().uuid().describe('Factory ID -- get from taiga_list_factories'),
+        type: z.string().describe('Document type (`team_instructions`)'),
         data: z.record(z.string(), z.unknown()).describe('Document content to save as JSON'),
       },
       { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       async (params) => {
-        const { teamId, type, ...body } = params;
-        const result = await client.saveTeamDocumentDraft(teamId, type, body as { data: Record<string, unknown> });
+        const { factoryId, type, ...body } = params;
+        const result = await client.saveFactoryDocumentDraft(
+          factoryId,
+          type,
+          body as { data: Record<string, unknown> }
+        );
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
         };

package/src/tools/index.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TaigaClient } from '../client.js';
-import { registerProjectTools } from './projects.js';
+import { registerProductTools } from './products.js';
 import { registerDocumentTools } from './documents.js';
 import { registerBacklogTools } from './backlogs.js';
 
@@ -9,11 +9,11 @@ import { registerBacklogTools } from './backlogs.js';
  * 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 team documents).
- * Post-beta: Projects, backlog items, environments, composite tools.
+ * Beta scope: Knowledge base access (policies and factory instructions).
+ * Post-beta: Products, backlog items, environments, composite tools.
  */
 export function registerAllTools(server: McpServer, client: TaigaClient): void {
-  registerProjectTools(server, client);
+  registerProductTools(server, client);
   registerDocumentTools(server, client);
   registerBacklogTools(server, client);
 }

package/src/tools/{projects.ts → products.ts}

@@ -3,19 +3,21 @@ import { z } from 'zod';
 import type { TaigaClient } from '../client.js';
 import { summarizeList } from './summarize.js';
 
-export function registerProjectTools(server: McpServer, client: TaigaClient) {
+// Capability strings still say teams/projects until the database rename (PRO-1671).
+export function registerProductTools(server: McpServer, client: TaigaClient) {
   if (client.hasCapability('teams:read')) {
     server.tool(
-      'taiga_list_teams',
-      'List all teams in the organization. Use this to find team IDs ' +
-        'for reading team documents and understanding team structure. ' +
-        'Teams own domain context, tech preferences, and architecture constraints.',
+      'taiga_list_factories',
+      '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.',
       {
         limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
       },
       { readOnlyHint: true, openWorldHint: false },
       async (params) => {
-        const result = await client.listTeams(params);
+        const result = await client.listFactories(params);
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
         };
@@ -25,25 +27,29 @@ export function registerProjectTools(server: McpServer, client: TaigaClient) {
 
   if (client.hasCapability('projects:read')) {
     server.tool(
-      'taiga_list_projects',
-      'List projects in the organization. Use this to find the project you are working on ' +
+      'taiga_list_products',
+      '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 team; a status filter also exists but no longer distinguishes anything (see its description).',
+        'Can filter by factory; a status filter also exists but no longer distinguishes anything (see its description).',
       {
-        teamId: z.string().uuid().optional().describe('Filter by team ID -- get team IDs from taiga_list_teams'),
+        factoryId: z
+          .string()
+          .uuid()
+          .optional()
+          .describe('Filter by factory ID -- get factory IDs from taiga_list_factories'),
         status: z
           .enum(['draft', 'active', 'archived'])
           .optional()
           .describe(
-            'Filter by status. Taiga no longer surfaces project status in its UI (PRO-543), so every ' +
-              'project is currently "draft" and filtering by "active" or "archived" returns nothing. ' +
+            '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)'),
       },
       { readOnlyHint: true, openWorldHint: false },
       async (params) => {
-        const result = await client.listProjects(params);
+        const result = await client.listProducts(params);
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
         };
@@ -51,19 +57,19 @@ export function registerProjectTools(server: McpServer, client: TaigaClient) {
     );
 
     server.tool(
-      'taiga_list_project_documents',
-      'List documents for a specific project (names and types only). ' +
-        'Project documents are generated during intake: specification (requirements), ' +
+      'taiga_list_product_documents',
+      '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, and user flow. ' +
-        'Use taiga_get_project_document to read the full content.',
+        'threat model (security risks), risk register, user flow, and service blueprint. ' +
+        'Use taiga_get_product_document to read the full content.',
       {
-        projectId: z.string().uuid().describe('Project ID -- get from taiga_list_projects'),
+        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)'),
       },
       { readOnlyHint: true, openWorldHint: false },
       async (params) => {
-        const result = await client.listProjectDocuments(params.projectId, { limit: params.limit });
+        const result = await client.listProductDocuments(params.productId, { limit: params.limit });
         const summaries = summarizeList(result.data as Record<string, unknown>[]);
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(summaries, null, 2) }],
@@ -72,25 +78,27 @@ export function registerProjectTools(server: McpServer, client: TaigaClient) {
     );
 
     server.tool(
-      'taiga_get_project_document',
-      'Get the full content of a specific project document. ' +
+      'taiga_get_product_document',
+      'Get the full content of a specific product document. ' +
         'Use this when you need to understand what to build (specification), ' +
         'how the system is designed (architecture), what security risks exist (threat model), ' +
         'or what technology choices were made (technology_decisions). ' +
         'Types: specification, architecture, technology_decisions, data_flow, ' +
-        'privacy_assessment, threat_model, risk_register, user_flow.',
+        'privacy_assessment, threat_model, risk_register, user_flow, service_blueprint, ' +
+        'ui_direction, codebase_snapshot. The product instructions document is ' +
+        '`project_instructions` (its stored type keeps the old name).',
       {
-        projectId: z.string().uuid().describe('Project ID -- get from taiga_list_projects'),
+        productId: z.string().uuid().describe('Product ID -- get from taiga_list_products'),
         type: z
           .string()
           .describe(
-            'Document type -- get available types from taiga_list_project_documents. ' +
+            'Document type -- get available types from taiga_list_product_documents. ' +
               'Common: specification, architecture, threat_model, technology_decisions'
           ),
       },
       { readOnlyHint: true, openWorldHint: false },
       async (params) => {
-        const result = await client.getProjectDocument(params.projectId, params.type);
+        const result = await client.getProductDocument(params.productId, params.type);
         return {
           content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
         };