@taiga-ai/mcp-server 0.2.3-dev.284 → 0.2.3-dev.286

package/dist/index.js

@@ -2,196 +2,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-//#region ../../packages/feature-flags/dist/index.js
-/**
-* Feature flags shared across web, api, mcp-server, and the documentation site.
-*
-* {@link featureFlagDefinitions} is the single source of truth for WHICH flags
-* exist, HOW each one resolves per environment, and what it is for; the
-* {@link FeatureFlags} type is derived from it. Every app calls
-* {@link resolveFeatureFlags} with its own environment identifier so a feature
-* is shown or hidden consistently everywhere from one rule set:
-*   - web: `resolveFeatureFlags(config.VITE_APP_ENV)` (baked at build time)
-*   - api: a fail-safe wrapper (`apps/api/src/shared/config/feature-flags.ts`)
-*     that resolves `ENVIRONMENT` and defaults to `prod` for any unrecognized
-*     value when deployed, so a WIP feature is never leaked
-*   - docs: `apps/docs/src/content.config.ts` resolves flags for the
-*     environment being built and DROPS pages carrying `flag: <name>` where
-*     that flag is off, so docs.tai.ga never describes a feature customers
-*     cannot see (PRO-1033)
-*
-* Flags are boot-time constants — no remote source. Changing a rule here
-* re-derives the flag everywhere.
-*
-* ## Adding a flag
-*
-* One entry in {@link featureFlagDefinitions}: its `availability`, a one-line
-* `description` for the web dev panel, and the full account of what it gates
-* and why as the JSDoc above the entry. If the flag is OFF in prod, two more
-* things follow, and the first will stop you:
-*
-* 1. **`make docs-check-claims` fails until the flag is registered** in
-*    `FLAG_PHRASES` (`apps/docs/scripts/check-claims.py`). That is deliberate:
-*    the check used to iterate its own dict, so an unregistered flag was never
-*    examined and a page could describe an invisible feature. Register the
-*    words a page would use for the feature, or `[]` if it has a page of its
-*    own that declares the flag.
-* 2. **A page for the feature can be written now**, carrying `flag: <name>` in
-*    its frontmatter. It is published on dev and staging and excluded from
-*    prod, and it publishes by itself when the flag graduates — no docs change.
-*    See the `flag:` section in `apps/docs/AGENTS.md`, which also covers the
-*    one constraint: nothing published may link to a flagged page.
-*/
-/**
-* THE registry: one entry per flag. Adding a flag is adding an entry here;
-* {@link FeatureFlags} and {@link resolveFeatureFlags} derive from it.
-*/
-const featureFlagDefinitions = Object.freeze({
-	/**
-	* Skills feature. When `false` the feature is fully dormant:
-	*   - web: nav groups, dashboard governance row, and skills routes are hidden
-	*   - api: the `/v1/agent-skills*` endpoints are not registered
-	*   - mcp: the skill tools, their instruction mentions, and the
-	*     `getProjectContext` skills summary are omitted
-	*   - agent runtime: no skills are injected into agent prompts
-	*   - seeding: no default skills are created for new tenants/teams/projects
-	*
-	* Hidden for now (not needed in the product yet; may return later).
-	*/
-	skills: {
-		description: "Agent skills: the skills routes and pages, the MCP skill tools, and skills injected into agent prompts. Hidden in every environment for now.",
-		availability: "nowhere"
-	},
-	/**
-	* Insights surface (Learn loop) — production feedback and customer signals
-	* feeding the next iteration.
-	*
-	* Release toggle: ON in local/dev/staging, OFF in prod. Surfaces the
-	* scaffold page in lower environments only while the feature is designed.
-	* **Remove this flag (and its gates) at GA.**
-	*/
-	insights: {
-		description: "Insights section of the Learn loop: production feedback and customer signals feeding the next iteration.",
-		availability: "non-prod"
-	},
-	/**
-	* UI Studio (PRO-630) — the workbench for AI-generated UI concepts of the
-	* CUSTOMER's app: the concept gallery, the sparring chat, iterate, and
-	* promoting an element into a Design Standards component. When `false` the
-	* workbench is fully dormant:
-	*   - web: the concept gallery, the Studio, the initiative cockpit's
-	*     direction card and the `/dev/ui-artifact-test` route are not
-	*     registered
-	*   - api: the Studio's own routes (persist, delete, feedback, iterate,
-	*     promote-component) are not registered, and their job assemblers refuse
-	*
-	* NOT under this flag: the Look & Feel document (PRO-1376) and everything it
-	* runs on -- the concept compile/list/read/choose routes, the direction job,
-	* "Propose 2 more", the planner's direction summary and the build-time
-	* direction. Those shipped in PRO-1537. The flow surface moved out from under
-	* this flag in PRO-1029 and graduated to production in PRO-1535; it carries
-	* no flag any more.
-	*
-	* Release toggle: ON in local/dev/staging, OFF in prod until the workbench
-	* has its own rollout decision. **Remove this flag (and its gates) at GA.**
-	*/
-	uiSparring: {
-		description: "UI Studio: the workbench for AI-generated UI concepts of the customer's application, with its own API endpoints. Look & Feel is not under it.",
-		availability: "non-prod"
-	},
-	/**
-	* Customer-definable check-and-stamp checklists (PRO-946..948, design
-	* PRO-933). When `false` the feature is fully dormant:
-	*   - api: the `/v1/checklist-*` endpoints are not registered
-	*   - api: no checklist instances are created on project creation (PR 2/3)
-	*   - web: no discovery-pipeline checklist step, no org-settings editor
-	*
-	* Release toggle: ON in local/dev/staging, OFF in prod while the three
-	* slices (schema/API → gate + project surface → template editor) land.
-	* **Remove this flag (and its gates) at GA.**
-	*/
-	checklists: {
-		description: "Customer-defined check-and-stamp checklists: the discovery pipeline step, the organization settings editor and their API endpoints.",
-		availability: "non-prod"
-	},
-	/**
-	* Factory v2 engineer pod (PRO-1313..1315, PRO-1331). Two roles:
-	*   - the admin-only `/v1/engineer/*` endpoints that trigger the EC2-backed
-	*     Runtime Instances probe runtime (when `false` the routes are not
-	*     registered, so nothing in the product can reach that runtime);
-	*   - the environment kill-switch for agent-runtime routing (PRO-1331): with
-	*     it on, a tenant holding a live `engineer_runtime` entitlement has its
-	*     initiative planning jobs and build runs routed to the engineer runtime
-	*     (fail-closed until the run contract lands, PRO-1333); with it off,
-	*     every tenant stays on the legacy agents whatever the entitlement rows
-	*     say.
-	* OFF in prod until the real engineer pod ships behind its own, separate
-	* rollout decision.
-	*/
-	engineerPod: {
-		description: "Factory v2 engineer pod: the admin-only /v1/engineer probe endpoints, and the kill-switch for routing engineer_runtime-entitled tenants to the engineer runtime (dev/staging only).",
-		availability: "non-prod"
-	},
-	/**
-	* Notification delivery (PRO-1553) -- taking an inbox item that needs a human
-	* and putting it in front of them somewhere other than the app.
-	*
-	* The first (and so far only) recipient type is an "alternate contact": a
-	* verified email address attached to an org or a project rather than to a
-	* person, in the AWS alternate-contacts sense. The flagship consumer is a
-	* Slack channel's email address, which is how a customer gets Taiga
-	* notifications into Slack without us shipping a Slack app.
-	*
-	* When `false` the feature is fully dormant:
-	*   - api: the `/v1/notification-recipients*` and
-	*     `/v1/projects/:id/notification-recipients` endpoints are not registered,
-	*     the delivery worker does not start, and the inbox raise path writes no
-	*     `notification_deliveries` rows -- so nothing is queued that a later
-	*     flag flip would suddenly send
-	*   - web: the notification-contacts card is not rendered in project settings
-	*
-	* Release toggle: ON everywhere as of 2026-09-13. What ships is the
-	* PROJECT-scoped contact: the org scope exists in the schema, the routing
-	* and the API, but no UI offers it and the docs page does not mention it,
-	* so it is dormant capability rather than a shipped feature. Per-user
-	* recipients, the preference matrix and digests are still unbuilt; they no
-	* longer sit behind this flag and want their own gate if they need one.
-	*
-	* The gate stays in place for one release so the feature can be turned off
-	* without a revert if prod surprises us. Turning it off is safe by
-	* construction and does not strand mail: with the flag false the routing
-	* path writes no `notification_deliveries` rows at all, so nothing
-	* accumulates to flood on a later flip.
-	* **Remove this flag (and its gates) once prod has run a release with it
-	* on.**
-	*/
-	notifications: {
-		description: "Notification delivery: verified per-scope email contacts (alternate contacts) that receive inbox items, plus the delivery queue and worker behind them.",
-		availability: "everywhere"
-	}
-});
-/** Every flag name, in registry order. */
-const featureFlagNames = Object.keys(featureFlagDefinitions);
-/**
-* Resolve the full flag set for an environment from the registry. Frozen so a
-* resolved set cannot be mutated at runtime — changing a flag is a source edit
-* in {@link featureFlagDefinitions}, not an assignment in an app.
-*/
-function resolveFeatureFlags(env) {
-	const isOn = (availability) => availability === "everywhere" || availability === "non-prod" && env !== "prod";
-	const resolved = {};
-	for (const name of featureFlagNames) resolved[name] = isOn(featureFlagDefinitions[name].availability);
-	return Object.freeze(resolved);
-}
-/**
-* Safe-default snapshot, resolved as `prod`: every still-gated release toggle
-* is off. Prefer
-* {@link resolveFeatureFlags} with the app's real environment. Retained for
-* consumers that have no environment of their own — notably the published MCP
-* server — so an unconfigured runtime never leaks a work-in-progress feature.
-*/
-const featureFlags = resolveFeatureFlags("prod");
-//#endregion
 //#region src/client.ts
 /**
 * HTTP client for the Taiga API.
@@ -279,33 +89,15 @@ var TaigaClient = class {
 	async getProjectDocument(projectId, type) {
 		return this.request("GET", `/projects/${projectId}/documents/${type}`);
 	}
-	async listSkills(opts) {
-		const params = new URLSearchParams();
-		if (opts?.scope) params.set("scope", opts.scope);
-		if (opts?.scopeId) params.set("scopeId", opts.scopeId);
-		if (opts?.limit) params.set("limit", String(opts.limit));
-		const qs = params.toString();
-		return this.request("GET", `/agent-skills${qs ? `?${qs}` : ""}`);
-	}
-	async getSkill(id) {
-		return this.request("GET", `/agent-skills/${id}`);
-	}
-	async updateSkill(id, body) {
-		return this.request("PATCH", `/agent-skills/${id}`, body);
-	}
 	/**
 	* Fetch the full context for a project in parallel: project metadata,
-	* team documents, project documents, and team skills.
+	* team documents and project documents.
 	* Returns a structured bundle optimized for coding agent consumption.
 	*/
 	async getProjectContext(projectId) {
 		const project = await this.request("GET", `/projects/${projectId}`);
 		const teamId = project.data.teamId;
-		const [projectDocs, teamDocs, skills] = await Promise.all([
-			this.listProjectDocuments(projectId, { limit: 20 }).catch(() => ({ data: [] })),
-			teamId ? this.listTeamDocuments(teamId, { limit: 20 }).catch(() => ({ data: [] })) : Promise.resolve({ data: [] }),
-			featureFlags.skills ? this.listSkills({ limit: 100 }).catch(() => ({ data: [] })) : Promise.resolve({ data: [] })
-		]);
+		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 = [
 			"specification",
 			"architecture",
@@ -338,7 +130,7 @@ var TaigaClient = class {
 			})));
 		}
 		const fetchedDocs = await Promise.all(docFetches);
-		const context = {
+		return {
 			project: project.data,
 			documents: {
 				project: Object.fromEntries(fetchedDocs.filter((d) => d.scope === "project" && d.data).map((d) => [d.type, d.data])),
@@ -359,13 +151,6 @@ var TaigaClient = class {
 				}))
 			}
 		};
-		if (featureFlags.skills) context.skills_summary = skills.data.filter((s) => !s.teamId || s.teamId === teamId).map((s) => ({
-			id: s.id,
-			name: s.name,
-			slug: s.slug,
-			description: s.description
-		}));
-		return context;
 	}
 	async listBacklogItems(projectId, opts) {
 		const params = new URLSearchParams();
@@ -417,7 +202,7 @@ 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, skills, 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)") }, {
+	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)") }, {
 		readOnlyHint: true,
 		openWorldHint: false
 	}, async (params) => {
@@ -562,63 +347,18 @@ function registerDocumentTools(server, client) {
 	});
 }
 //#endregion
-//#region src/tools/skills.ts
-function registerSkillTools(server, client) {
-	if (client.hasCapability("tenant:documents:read")) {
-		server.tool("taiga_list_skills", "List agent skills available in the organization (names and descriptions only). Skills are reusable knowledge modules that guide coding: coding standards, security requirements, architecture patterns, database conventions, etc. Use taiga_get_skill with the skill ID to read the full content.", { limit: z.number().min(1).max(100).optional().describe("Max results (default 25)") }, {
-			readOnlyHint: true,
-			openWorldHint: false
-		}, async (params) => {
-			const summaries = summarizeList((await client.listSkills(params)).data);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(summaries, null, 2)
-			}] };
-		});
-		server.tool("taiga_get_skill", "Get the full content of a specific agent skill. Use this when you need detailed coding guidelines, patterns, or conventions for a specific topic (e.g., security requirements, API design, testing strategy). Returns the complete markdown content with code examples and best practices.", { id: z.string().uuid().describe("Skill ID -- get from taiga_list_skills") }, {
-			readOnlyHint: true,
-			openWorldHint: false
-		}, async (params) => {
-			const result = await client.getSkill(params.id);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result.data, null, 2)
-			}] };
-		});
-	}
-	if (client.hasCapability("tenant:documents:write")) server.tool("taiga_update_skill", "Update an agent skill (coding standards, patterns, conventions). Use this when you notice a skill is outdated, incomplete, or needs corrections while working on the codebase. Changes are saved immediately.", {
-		id: z.string().uuid().describe("Skill ID -- get from taiga_list_skills"),
-		name: z.string().optional().describe("Updated skill name"),
-		description: z.string().optional().describe("Updated skill description"),
-		content: z.string().optional().describe("Updated skill content (markdown)")
-	}, {
-		readOnlyHint: false,
-		destructiveHint: false,
-		idempotentHint: true,
-		openWorldHint: false
-	}, async (params) => {
-		const { id, ...body } = params;
-		const result = await client.updateSkill(id, body);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result.data, null, 2)
-		}] };
-	});
-}
-//#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, skills, team documents).
+* Beta scope: Knowledge base access (policies and team documents).
 * Post-beta: Projects, backlog items, environments, composite tools.
 */
 function registerAllTools(server, client) {
 	registerProjectTools(server, client);
 	registerDocumentTools(server, client);
-	if (featureFlags.skills) registerSkillTools(server, client);
 }
 //#endregion
 //#region src/index.ts
@@ -659,18 +399,12 @@ 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 project context.",
 		"",
-		...featureFlags.skills ? [
-			"**Skills** (taiga_list_skills / taiga_get_skill):",
-			"Coding standards, security requirements, API design patterns, testing strategy, database patterns,",
-			"and more. These are detailed engineering guidelines with code examples.",
-			""
-		] : [],
 		"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,",
-		featureFlags.skills ? "then read its specification and architecture. Use skills for coding patterns." : "then read its specification and architecture.",
+		"then read its specification and architecture.",
 		"",
-		featureFlags.skills ? "When you notice a policy, skill, or team document is outdated, use the update tools" : "When you notice a policy or team document is outdated, use the update tools",
-		featureFlags.skills ? "(taiga_update_document, taiga_update_skill, taiga_update_team_document) to fix it." : "(taiga_update_document, taiga_update_team_document) to fix it.",
+		"When you notice a policy or team document is outdated, use the update tools",
+		"(taiga_update_document, taiga_update_team_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.2.3-dev.284",
-  "description": "MCP server for Taiga -- gives AI assistants access to documents, skills, and projects",
+  "version": "0.2.3-dev.286",
+  "description": "MCP server for Taiga -- gives AI assistants access to documents and projects",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {

package/src/client.test.ts

@@ -231,25 +231,6 @@ describe('TaigaClient', () => {
       });
     });
 
-    it('should GET a single skill by id from agent-skills path', async () => {
-      const spy = stubFetch(200, { data: { id: 's1' } });
-
-      await makeClient().getSkill('s1');
-
-      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/agent-skills/s1');
-    });
-
-    it('should include scope filters when listing skills', async () => {
-      const spy = stubFetch(200, { data: [], nextCursor: null });
-
-      await makeClient().listSkills({ scope: 'team', scopeId: 't1', limit: 10 });
-
-      const url = spy.mock.calls[0][0] as string;
-      expect(url).toContain('/v1/agent-skills');
-      expect(url).toContain('scope=team');
-      expect(url).toContain('scopeId=t1');
-    });
-
     it('should GET a single backlog item by id (flat path)', async () => {
       const spy = stubFetch(200, { data: { id: 'item-1' } });
 

package/src/client.ts

@@ -1,5 +1,4 @@
 import type { ApiKeyIntrospection } from '@taiga/types';
-import { featureFlags } from '@taiga/feature-flags';
 
 /**
  * HTTP client for the Taiga API.
@@ -135,34 +134,13 @@ export class TaigaClient {
     return this.request<{ data: unknown }>('GET', `/projects/${projectId}/documents/${type}`);
   }
 
-  // ---------------------------------------------------------------------------
-  // Skills (agent skills)
-  // ---------------------------------------------------------------------------
-
-  async listSkills(opts?: { scope?: string; scopeId?: string; limit?: number }) {
-    const params = new URLSearchParams();
-    if (opts?.scope) params.set('scope', opts.scope);
-    if (opts?.scopeId) params.set('scopeId', opts.scopeId);
-    if (opts?.limit) params.set('limit', String(opts.limit));
-    const qs = params.toString();
-    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/agent-skills${qs ? `?${qs}` : ''}`);
-  }
-
-  async getSkill(id: string) {
-    return this.request<{ data: unknown }>('GET', `/agent-skills/${id}`);
-  }
-
-  async updateSkill(id: string, body: { name?: string; description?: string; content?: string }) {
-    return this.request<{ data: unknown }>('PATCH', `/agent-skills/${id}`, body);
-  }
-
   // ---------------------------------------------------------------------------
   // Team Documents
   // ---------------------------------------------------------------------------
 
   /**
    * Fetch the full context for a project in parallel: project metadata,
-   * team documents, project documents, and team skills.
+   * team documents and project documents.
    * Returns a structured bundle optimized for coding agent consumption.
    */
   async getProjectContext(projectId: string): Promise<Record<string, unknown>> {
@@ -170,17 +148,12 @@ export class TaigaClient {
     const project = await this.request<{ data: Record<string, unknown> }>('GET', `/projects/${projectId}`);
     const teamId = project.data.teamId as string | undefined;
 
-    // Fetch everything in parallel. Skills is hidden behind a feature flag
-    // (user-facing surface only), so skip its fetch entirely when disabled —
-    // the endpoint would 404 otherwise.
-    const [projectDocs, teamDocs, skills] = await Promise.all([
+    // 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: [] }))
         : Promise.resolve({ data: [] }),
-      featureFlags.skills
-        ? this.listSkills({ limit: 100 }).catch(() => ({ data: [] }))
-        : Promise.resolve({ data: [] as unknown[] }),
     ]);
 
     // Fetch full content for key documents (in parallel)
@@ -240,12 +213,6 @@ export class TaigaClient {
       },
     };
 
-    if (featureFlags.skills) {
-      context.skills_summary = (skills.data as Record<string, unknown>[])
-        .filter((s) => !s.teamId || s.teamId === teamId)
-        .map((s) => ({ id: s.id, name: s.name, slug: s.slug, description: s.description }));
-    }
-
     return context;
   }
 

package/src/index.ts

@@ -2,7 +2,6 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { featureFlags } from '@taiga/feature-flags';
 import { TaigaClient } from './client.js';
 import { registerAllTools } from './tools/index.js';
 
@@ -51,27 +50,12 @@ 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 project context.',
         '',
-        // Skills is hidden behind a feature flag (user-facing surface only).
-        ...(featureFlags.skills
-          ? [
-              '**Skills** (taiga_list_skills / taiga_get_skill):',
-              'Coding standards, security requirements, API design patterns, testing strategy, database patterns,',
-              'and more. These are detailed engineering guidelines with code examples.',
-              '',
-            ]
-          : []),
         "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,',
-        featureFlags.skills
-          ? 'then read its specification and architecture. Use skills for coding patterns.'
-          : 'then read its specification and architecture.',
+        'then read its specification and architecture.',
         '',
-        featureFlags.skills
-          ? 'When you notice a policy, skill, or team document is outdated, use the update tools'
-          : 'When you notice a policy or team document is outdated, use the update tools',
-        featureFlags.skills
-          ? '(taiga_update_document, taiga_update_skill, taiga_update_team_document) to fix it.'
-          : '(taiga_update_document, taiga_update_team_document) to fix it.',
+        'When you notice a policy or team document is outdated, use the update tools',
+        '(taiga_update_document, taiga_update_team_document) to fix it.',
         'This keeps the knowledge base accurate for everyone.',
       ].join('\n'),
     }

package/src/server.integration.test.ts

@@ -5,11 +5,6 @@ import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
 import { TaigaClient } from './client.js';
 import { registerAllTools } from './tools/index.js';
 
-// Skills is hidden behind a feature flag. Mock the shared flag with a mutable
-// object so tests can exercise both the default (off) and enabled states.
-const { mockFeatureFlags } = vi.hoisted(() => ({ mockFeatureFlags: { skills: false } }));
-vi.mock('@taiga/feature-flags', () => ({ featureFlags: mockFeatureFlags }));
-
 // ---------------------------------------------------------------------------
 // Helpers -- thin wrappers, not abstraction layers
 // ---------------------------------------------------------------------------
@@ -24,11 +19,10 @@ const ALL_CAPABILITIES = [
 ];
 
 /**
- * Tool names registered when the skills feature flag is OFF (the shipped
- * default), sorted for deterministic comparison. The three skill tools
- * (taiga_list_skills / taiga_get_skill / taiga_update_skill) are excluded.
+ * Every tool name the server registers for a key with all capabilities,
+ * sorted for deterministic comparison.
  */
-const BASE_TOOL_NAMES = [
+const ALL_TOOL_NAMES = [
   'taiga_get_document',
   'taiga_get_project_document',
   'taiga_get_team_document',
@@ -126,7 +120,6 @@ function parseToolResult(result: Record<string, unknown>) {
 describe('MCP server integration', () => {
   beforeEach(() => {
     vi.restoreAllMocks();
-    mockFeatureFlags.skills = false;
   });
 
   // -------------------------------------------------------------------------
@@ -136,23 +129,12 @@ describe('MCP server integration', () => {
   // -------------------------------------------------------------------------
 
   describe('tool discovery', () => {
-    it('should expose all non-skill tools when API key has full capabilities', async () => {
+    it('should expose every tool when API key has full capabilities', async () => {
       const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 
       const { tools } = await client.listTools();
 
-      // Skills is flag-off by default, so the skill tools are not registered.
-      expect(toolNames(tools)).toEqual(BASE_TOOL_NAMES);
-    });
-
-    it('should not register skill tools when the skills flag is off', async () => {
-      const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
-
-      const names = toolNames((await client.listTools()).tools);
-
-      expect(names).not.toContain('taiga_list_skills');
-      expect(names).not.toContain('taiga_get_skill');
-      expect(names).not.toContain('taiga_update_skill');
+      expect(toolNames(tools)).toEqual(ALL_TOOL_NAMES);
     });
 
     it('should reject tools/list when API key has no capabilities', async () => {
@@ -185,9 +167,6 @@ describe('MCP server integration', () => {
 
       expect(names).toContain('taiga_list_documents');
       expect(names).toContain('taiga_get_document');
-      // Skills is flag-off by default.
-      expect(names).not.toContain('taiga_list_skills');
-      expect(names).not.toContain('taiga_get_skill');
       expect(names).not.toContain('taiga_update_document');
     });
 
@@ -200,8 +179,6 @@ describe('MCP server integration', () => {
       const names = toolNames(tools);
 
       expect(names).toContain('taiga_update_document');
-      // Skills is flag-off by default.
-      expect(names).not.toContain('taiga_update_skill');
     });
 
     it('should expose team document write when both teams:read and documents:write are granted', async () => {
@@ -229,11 +206,8 @@ describe('MCP server integration', () => {
       expect(names).toContain('taiga_list_team_documents');
       // tenant:documents:read tools present
       expect(names).toContain('taiga_list_documents');
-      // skills flag-off by default
-      expect(names).not.toContain('taiga_list_skills');
       // write tools absent
       expect(names).not.toContain('taiga_update_document');
-      expect(names).not.toContain('taiga_update_skill');
     });
 
     it('should provide a description and input schema for every tool', async () => {
@@ -259,8 +233,6 @@ describe('MCP server integration', () => {
     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'],
-      // Skills tools are flag-off by default; their capability gating is covered
-      // in the 'when the skills feature flag is enabled' block below.
       'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document'],
       'tenant:documents:write': ['taiga_update_document'],
     };
@@ -429,67 +401,4 @@ describe('MCP server integration', () => {
       expect(result.isError).toBe(true);
     });
   });
-
-  // -------------------------------------------------------------------------
-  // Skills feature flag -- when enabled, the skill tools register and behave
-  // exactly like the other knowledge-base tools. This preserves coverage of
-  // the skill tools for the day the flag is flipped back on.
-  // -------------------------------------------------------------------------
-
-  describe('when the skills feature flag is enabled', () => {
-    beforeEach(() => {
-      mockFeatureFlags.skills = true;
-    });
-
-    it('registers read skill tools for a documents:read key', async () => {
-      const { client } = await bootMcpPair({ capabilities: ['tenant:documents:read'] });
-
-      const names = toolNames((await client.listTools()).tools);
-
-      expect(names).toContain('taiga_list_skills');
-      expect(names).toContain('taiga_get_skill');
-    });
-
-    it('registers taiga_update_skill with documents:write', async () => {
-      const { client } = await bootMcpPair({
-        capabilities: ['tenant:documents:read', 'tenant:documents:write'],
-      });
-
-      const names = toolNames((await client.listTools()).tools);
-
-      expect(names).toContain('taiga_update_skill');
-    });
-
-    it('should return skills through MCP protocol', async () => {
-      const skills = [{ id: 's1', name: 'React Standards' }];
-
-      const { client } = await bootMcpPair({
-        capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/agent-skills': { data: skills, nextCursor: null } },
-      });
-
-      const result = await client.callTool({ name: 'taiga_list_skills', arguments: {} });
-
-      expect(parseToolResult(result)).toEqual(skills);
-    });
-
-    it('should send PATCH when updating a skill', async () => {
-      const skillId = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5c';
-      const updated = { id: skillId, name: 'Updated Skill', content: '# Updated' };
-
-      const { client, fetchSpy } = await bootMcpPair({
-        capabilities: ALL_CAPABILITIES,
-        routes: { [`PATCH /v1/agent-skills/${skillId}`]: { data: updated } },
-      });
-
-      await client.callTool({
-        name: 'taiga_update_skill',
-        arguments: { id: skillId, content: '# Updated' },
-      });
-
-      const patchCall = fetchSpy.mock.calls.find((c: unknown[]) => (c[1] as RequestInit)?.method === 'PATCH');
-      expect(patchCall).toBeDefined();
-      expect(patchCall![0]).toContain(`/v1/agent-skills/${skillId}`);
-    });
-  });
 });

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, skills, team docs).
+// The beta MCP server focuses on the knowledge base (policies, team docs).
 
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TaigaClient } from '../client.js';

package/src/tools/index.ts

@@ -1,25 +1,19 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { featureFlags } from '@taiga/feature-flags';
 import type { TaigaClient } from '../client.js';
 import { registerProjectTools } from './projects.js';
 import { registerDocumentTools } from './documents.js';
 import { registerBacklogTools } from './backlogs.js';
-import { registerSkillTools } from './skills.js';
 
 /**
  * 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, skills, team documents).
+ * Beta scope: Knowledge base access (policies and team documents).
  * Post-beta: Projects, backlog items, environments, composite tools.
  */
 export function registerAllTools(server: McpServer, client: TaigaClient): void {
   registerProjectTools(server, client);
   registerDocumentTools(server, client);
   registerBacklogTools(server, client);
-  // Skills is hidden behind a feature flag (user-facing surface only).
-  if (featureFlags.skills) {
-    registerSkillTools(server, client);
-  }
 }

package/src/tools/projects.ts

@@ -8,7 +8,7 @@ export function registerProjectTools(server: McpServer, client: TaigaClient) {
     server.tool(
       'taiga_list_teams',
       'List all teams in the organization. Use this to find team IDs ' +
-        'for reading team documents, skills, and understanding team structure. ' +
+        '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)'),

package/src/tools/skills.ts

@@ -1,68 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { TaigaClient } from '../client.js';
-import { summarizeList } from './summarize.js';
-
-export function registerSkillTools(server: McpServer, client: TaigaClient) {
-  if (client.hasCapability('tenant:documents:read')) {
-    server.tool(
-      'taiga_list_skills',
-      'List agent skills available in the organization (names and descriptions only). ' +
-        'Skills are reusable knowledge modules that guide coding: coding standards, ' +
-        'security requirements, architecture patterns, database conventions, etc. ' +
-        'Use taiga_get_skill with the skill ID to read the full content.',
-      {
-        limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-      },
-      { readOnlyHint: true, openWorldHint: false },
-      async (params) => {
-        const result = await client.listSkills(params);
-        const summaries = summarizeList(result.data as Record<string, unknown>[]);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(summaries, null, 2) }],
-        };
-      }
-    );
-
-    server.tool(
-      'taiga_get_skill',
-      'Get the full content of a specific agent skill. ' +
-        'Use this when you need detailed coding guidelines, patterns, or conventions ' +
-        'for a specific topic (e.g., security requirements, API design, testing strategy). ' +
-        'Returns the complete markdown content with code examples and best practices.',
-      {
-        id: z.string().uuid().describe('Skill ID -- get from taiga_list_skills'),
-      },
-      { readOnlyHint: true, openWorldHint: false },
-      async (params) => {
-        const result = await client.getSkill(params.id);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
-        };
-      }
-    );
-  }
-
-  if (client.hasCapability('tenant:documents:write')) {
-    server.tool(
-      'taiga_update_skill',
-      'Update an agent skill (coding standards, patterns, conventions). ' +
-        'Use this when you notice a skill is outdated, incomplete, or needs corrections ' +
-        'while working on the codebase. Changes are saved immediately.',
-      {
-        id: z.string().uuid().describe('Skill ID -- get from taiga_list_skills'),
-        name: z.string().optional().describe('Updated skill name'),
-        description: z.string().optional().describe('Updated skill description'),
-        content: z.string().optional().describe('Updated skill content (markdown)'),
-      },
-      { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-      async (params) => {
-        const { id, ...body } = params;
-        const result = await client.updateSkill(id, body);
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
-        };
-      }
-    );
-  }
-}