@taiga-ai/mcp-server 0.0.1-dev.59 → 0.0.1-dev.62

package/dist/tools/projects.js

@@ -1,30 +1,61 @@
 import { z } from 'zod';
+import { summarizeList } from './summarize.js';
 export function registerProjectTools(server, client) {
-    if (client.hasCapability('projects:read')) {
-        server.tool('taiga_list_projects', 'List all projects in the organization. Returns project name, status, team, and metadata.', {
-            teamId: z.string().uuid().optional().describe('Filter by team ID'),
-            status: z.enum(['draft', 'active', 'archived']).optional().describe('Filter by status'),
+    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)'),
-        }, async (params) => {
-            const result = await client.listProjects(params);
+        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
+            const result = await client.listTeams(params);
             return {
                 content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
             };
         });
-        server.tool('taiga_get_project', 'Get detailed information about a specific project by ID.', {
-            id: z.string().uuid().describe('Project ID'),
-        }, async (params) => {
-            const result = await client.getProject(params.id);
+    }
+    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 or status.', {
+            teamId: z.string().uuid().optional().describe('Filter by team ID -- get team IDs from taiga_list_teams'),
+            status: z
+                .enum(['draft', 'active', 'archived'])
+                .optional()
+                .describe('Filter by status (draft = intake in progress, active = development)'),
+            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);
             return {
                 content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
             };
         });
-    }
-    if (client.hasCapability('teams:read')) {
-        server.tool('taiga_list_teams', 'List all teams in the organization.', {
+        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'),
             limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
-        }, async (params) => {
-            const result = await client.listTeams(params);
+        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
+            const result = await client.listProjectDocuments(params.projectId, { limit: params.limit });
+            const summaries = summarizeList(result.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'),
+        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
+            const result = await client.getProjectDocument(params.projectId, params.type);
             return {
                 content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
             };

package/dist/tools/skills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/tools/skills.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,QAkCxE"}
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/tools/skills.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,QA8DxE"}

package/dist/tools/skills.js

@@ -1,25 +1,45 @@
 import { z } from 'zod';
+import { summarizeList } from './summarize.js';
 export function registerSkillTools(server, client) {
-    // Skills require tenant:documents:read as they're part of the knowledge base
     if (client.hasCapability('tenant:documents:read')) {
-        server.tool('taiga_list_skills', 'List agent skills available in the organization. ' +
-            'Skills are reusable knowledge modules that guide AI agents (coding standards, ' +
-            'architecture patterns, deployment procedures, etc).', {
+        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)'),
-        }, async (params) => {
+        }, { readOnlyHint: true, openWorldHint: false }, async (params) => {
             const result = await client.listSkills(params);
+            const summaries = summarizeList(result.data);
             return {
-                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(summaries, null, 2) }],
             };
         });
-        server.tool('taiga_get_skill', 'Get the full content of a specific agent skill by ID. ' +
-            'Returns the skill definition including instructions, context, and metadata.', {
-            id: z.string().uuid().describe('Skill ID'),
-        }, async (params) => {
+        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) }],
+            };
+        });
+    }
 }

package/dist/tools/summarize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Strip heavy content from list responses to avoid context window bloat.
+ *
+ * List endpoints return summaries (id, name, description, metadata).
+ * Get endpoints return the full content.
+ *
+ * This keeps list calls cheap (~100 tokens per item) and lets the AI
+ * selectively load full content only for the items it needs.
+ */
+/**
+ * Remove heavy content fields from each item in an array.
+ * Preserves all metadata (id, name, description, type, dates, etc).
+ */
+export declare function summarizeList<T extends Record<string, unknown>>(items: T[]): Omit<T, 'content' | 'data' | 'sections'>[];
+//# sourceMappingURL=summarize.d.ts.map

package/dist/tools/summarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../src/tools/summarize.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,KAAK,EAAE,CAAC,EAAE,GACT,IAAI,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,CAAC,EAAE,CAU5C"}

package/dist/tools/summarize.js

@@ -0,0 +1,26 @@
+/**
+ * Strip heavy content from list responses to avoid context window bloat.
+ *
+ * List endpoints return summaries (id, name, description, metadata).
+ * Get endpoints return the full content.
+ *
+ * This keeps list calls cheap (~100 tokens per item) and lets the AI
+ * selectively load full content only for the items it needs.
+ */
+/** Fields to strip from list responses -- these contain the bulk content. */
+const HEAVY_FIELDS = ['content', 'data', 'sections'];
+/**
+ * Remove heavy content fields from each item in an array.
+ * Preserves all metadata (id, name, description, type, dates, etc).
+ */
+export function summarizeList(items) {
+    return items.map((item) => {
+        const summary = { ...item };
+        for (const field of HEAVY_FIELDS) {
+            if (field in summary) {
+                delete summary[field];
+            }
+        }
+        return summary;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.0.1-dev.59",
+  "version": "0.0.1-dev.62",
   "description": "MCP server for Taiga -- gives AI assistants access to documents, skills, and projects",
   "type": "module",
   "main": "./dist/index.js",

package/src/client.ts

@@ -94,6 +94,46 @@ export class TaigaClient {
     return this.request<{ data: unknown }>('PUT', `/tenants/current/documents/${type}/draft`, body);
   }
 
+  // ---------------------------------------------------------------------------
+  // Team Documents
+  // ---------------------------------------------------------------------------
+
+  async listTeamDocuments(teamId: 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',
+      `/teams/${teamId}/documents${qs ? `?${qs}` : ''}`
+    );
+  }
+
+  async getTeamDocument(teamId: string, type: string) {
+    return this.request<{ data: unknown }>('GET', `/teams/${teamId}/documents/${type}`);
+  }
+
+  async saveTeamDocumentDraft(teamId: string, type: string, body: { data: Record<string, unknown> }) {
+    return this.request<{ data: unknown }>('PUT', `/teams/${teamId}/documents/${type}/draft`, body);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Project Documents
+  // ---------------------------------------------------------------------------
+
+  async listProjectDocuments(projectId: 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',
+      `/projects/${projectId}/documents${qs ? `?${qs}` : ''}`
+    );
+  }
+
+  async getProjectDocument(projectId: string, type: string) {
+    return this.request<{ data: unknown }>('GET', `/projects/${projectId}/documents/${type}`);
+  }
+
   // ---------------------------------------------------------------------------
   // Skills (agent skills)
   // ---------------------------------------------------------------------------
@@ -111,6 +151,96 @@ export class TaigaClient {
     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.
+   * Returns a structured bundle optimized for coding agent consumption.
+   */
+  async getProjectContext(projectId: string): Promise<Record<string, unknown>> {
+    // First fetch the project to get the teamId
+    const project = await this.request<{ data: Record<string, unknown> }>('GET', `/projects/${projectId}`);
+    const teamId = project.data.teamId as string | undefined;
+
+    // Fetch everything in parallel
+    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: [] }),
+      this.listSkills({ limit: 100 }).catch(() => ({ data: [] })),
+    ]);
+
+    // Fetch full content for key documents (in parallel)
+    const keyProjectDocTypes = ['specification', 'architecture', 'technology_decisions'];
+    const keyTeamDocTypes = ['domain_context', 'tech_preferences', 'architecture_constraints'];
+
+    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);
+      if (exists) {
+        docFetches.push(
+          this.getProjectDocument(projectId, docType)
+            .then((r) => ({ type: docType, scope: 'project', data: r.data }))
+            .catch(() => ({ type: docType, scope: 'project', 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 (exists) {
+          docFetches.push(
+            this.getTeamDocument(teamId, docType)
+              .then((r) => ({ type: docType, scope: 'team', data: r.data }))
+              .catch(() => ({ type: docType, scope: 'team', data: null }))
+          );
+        }
+      }
+    }
+
+    const fetchedDocs = await Promise.all(docFetches);
+
+    // Assemble context bundle
+    const context: Record<string, unknown> = {
+      project: project.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])),
+      },
+      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,
+        })),
+      },
+      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;
+  }
+
   // ---------------------------------------------------------------------------
   // Backlog
   // ---------------------------------------------------------------------------

package/src/index.ts

@@ -27,11 +27,43 @@ async function main() {
     process.exit(1);
   });
 
-  // Create MCP server with dynamic tool registration
-  const server = new McpServer({
-    name: 'taiga',
-    version: '0.0.1',
-  });
+  // Create MCP server with dynamic tool registration and instructions
+  const server = new McpServer(
+    {
+      name: 'taiga',
+      version: '0.0.1',
+    },
+    {
+      instructions: [
+        'You have access to Taiga -- a policy-aware software development platform.',
+        "Taiga provides your organization's engineering knowledge base:",
+        '',
+        '**Company policies** (taiga_list_documents / taiga_get_document):',
+        '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.',
+        '',
+        '**Project documents** (taiga_list_project_documents / taiga_get_project_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.',
+        '',
+        '**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,',
+        'then read its specification and architecture. Use skills for coding patterns.',
+        '',
+        'When you notice a policy, skill, or team document is outdated, use the update tools',
+        '(taiga_update_document, taiga_update_skill, taiga_update_team_document) to fix it.',
+        'This keeps the knowledge base accurate for everyone.',
+      ].join('\n'),
+    }
+  );
 
   registerAllTools(server, client);
 

package/src/server.integration.test.ts

@@ -20,17 +20,19 @@ const ALL_CAPABILITIES = [
 
 /** All tool names the server can register (sorted for deterministic comparison). */
 const ALL_TOOL_NAMES = [
-  'taiga_get_backlog_item',
   'taiga_get_document',
-  'taiga_get_project',
+  'taiga_get_project_document',
   'taiga_get_skill',
-  'taiga_list_backlog_items',
+  'taiga_get_team_document',
   'taiga_list_documents',
-  'taiga_list_environments',
+  'taiga_list_project_documents',
   'taiga_list_projects',
   'taiga_list_skills',
+  'taiga_list_team_documents',
   'taiga_list_teams',
   'taiga_update_document',
+  'taiga_update_skill',
+  'taiga_update_team_document',
 ];
 
 function makeFetchRouter(routes: Record<string, unknown>) {
@@ -127,7 +129,7 @@ describe('MCP server integration', () => {
   // -------------------------------------------------------------------------
 
   describe('tool discovery', () => {
-    it('should expose all 11 tools when API key has full capabilities', async () => {
+    it('should expose all 13 tools when API key has full capabilities', async () => {
       const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 
       const { tools } = await client.listTools();
@@ -144,17 +146,17 @@ describe('MCP server integration', () => {
       await expect(client.listTools()).rejects.toThrow(/Method not found/);
     });
 
-    it('should expose only project tools for a projects:read-only key', async () => {
-      const { client } = await bootMcpPair({ capabilities: ['projects:read'] });
+    it('should expose only team 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_projects');
-      expect(names).toContain('taiga_get_project');
-      expect(names).toContain('taiga_list_environments');
-      expect(names).not.toContain('taiga_list_teams');
+      expect(names).toContain('taiga_list_teams');
+      expect(names).toContain('taiga_list_team_documents');
+      expect(names).toContain('taiga_get_team_document');
       expect(names).not.toContain('taiga_list_documents');
+      expect(names).not.toContain('taiga_update_document');
     });
 
     it('should expose read-only document tools without write capability', async () => {
@@ -170,43 +172,47 @@ describe('MCP server integration', () => {
       expect(names).not.toContain('taiga_update_document');
     });
 
-    it('should expose update tool when documents:write is also granted', async () => {
+    it('should expose write tools when documents:write is also granted', async () => {
       const { client } = await bootMcpPair({
         capabilities: ['tenant:documents:read', 'tenant:documents:write'],
       });
 
       const { tools } = await client.listTools();
+      const names = toolNames(tools);
 
-      expect(toolNames(tools)).toContain('taiga_update_document');
+      expect(names).toContain('taiga_update_document');
+      expect(names).toContain('taiga_update_skill');
     });
 
-    it('should expose backlog tools only with backlog:read', async () => {
-      const { client } = await bootMcpPair({ capabilities: ['backlog:read'] });
+    it('should expose team document write when both teams:read and documents:write are granted', async () => {
+      const { client } = await bootMcpPair({
+        capabilities: ['teams:read', 'tenant:documents:write'],
+      });
 
       const { tools } = await client.listTools();
       const names = toolNames(tools);
 
-      expect(names).toContain('taiga_list_backlog_items');
-      expect(names).toContain('taiga_get_backlog_item');
-      expect(names).not.toContain('taiga_list_environments');
+      expect(names).toContain('taiga_update_team_document');
+      expect(names).toContain('taiga_list_teams');
     });
 
     it('should combine capabilities additively', async () => {
       const { client } = await bootMcpPair({
-        capabilities: ['projects:read', 'backlog:read'],
+        capabilities: ['teams:read', 'tenant:documents:read'],
       });
 
       const { tools } = await client.listTools();
       const names = toolNames(tools);
 
-      // projects:read tools present
-      expect(names).toContain('taiga_list_projects');
-      expect(names).toContain('taiga_list_environments');
-      // backlog:read tools present
-      expect(names).toContain('taiga_list_backlog_items');
-      // unrelated capabilities absent
-      expect(names).not.toContain('taiga_list_documents');
-      expect(names).not.toContain('taiga_list_teams');
+      // teams:read tools present
+      expect(names).toContain('taiga_list_teams');
+      expect(names).toContain('taiga_list_team_documents');
+      // tenant:documents:read tools present
+      expect(names).toContain('taiga_list_documents');
+      expect(names).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 () => {
@@ -230,11 +236,10 @@ describe('MCP server integration', () => {
 
   describe('capability-tool contract', () => {
     const CONTRACT: Record<string, string[]> = {
-      'projects:read': ['taiga_list_projects', 'taiga_get_project', 'taiga_list_environments'],
-      'teams:read': ['taiga_list_teams'],
+      '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'],
       'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document', 'taiga_list_skills', 'taiga_get_skill'],
-      'tenant:documents:write': ['taiga_update_document'],
-      'backlog:read': ['taiga_list_backlog_items', 'taiga_get_backlog_item'],
+      'tenant:documents:write': ['taiga_update_document', 'taiga_update_skill'],
     };
 
     for (const [capability, expectedTools] of Object.entries(CONTRACT)) {
@@ -258,38 +263,40 @@ describe('MCP server integration', () => {
   // -------------------------------------------------------------------------
 
   describe('tool execution', () => {
-    it('should return project list as JSON text content', async () => {
-      const projects = [
-        { id: 'p1', name: 'Alpha' },
-        { id: 'p2', name: 'Beta' },
+    it('should return team list as JSON text content', async () => {
+      const teams = [
+        { id: 't1', name: 'Product' },
+        { id: 't2', name: 'Platform' },
       ];
 
       const { client } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/projects': { data: projects, nextCursor: null } },
+        routes: { 'GET /v1/teams': { data: teams, nextCursor: null } },
       });
 
-      const result = await client.callTool({ name: 'taiga_list_projects', arguments: {} });
+      const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });
 
       expect(result.content).toHaveLength(1);
-      expect(parseToolResult(result)).toEqual(projects);
+      expect(parseToolResult(result)).toEqual(teams);
     });
 
-    it('should pass project id through to the API', async () => {
-      const projectId = '00000000-0000-0000-0000-000000000001';
-      const project = { id: projectId, name: 'Alpha', status: 'active' };
+    it('should send PATCH when updating a skill', async () => {
+      const skillId = '00000000-0000-0000-0000-000000000001';
+      const updated = { id: skillId, name: 'Updated Skill', content: '# Updated' };
 
-      const { client } = await bootMcpPair({
+      const { client, fetchSpy } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { [`GET /v1/projects/${projectId}`]: { data: project } },
+        routes: { [`PATCH /v1/agent-skills/${skillId}`]: { data: updated } },
       });
 
-      const result = await client.callTool({
-        name: 'taiga_get_project',
-        arguments: { id: projectId },
+      await client.callTool({
+        name: 'taiga_update_skill',
+        arguments: { id: skillId, content: '# Updated' },
       });
 
-      expect(parseToolResult(result)).toEqual(project);
+      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}`);
     });
 
     it('should return document content through MCP protocol', async () => {
@@ -324,21 +331,26 @@ describe('MCP server integration', () => {
       expect(putCall![0]).toContain(`/v1/tenants/current/documents/${docType}/draft`);
     });
 
-    it('should pass projectId to backlog items endpoint', async () => {
-      const projectId = '00000000-0000-0000-0000-000000000001';
-      const items = [{ id: 'bi1', name: 'Feature X' }];
+    it('should send PUT when updating a team document draft', async () => {
+      const teamId = '00000000-0000-0000-0000-000000000001';
+      const docType = 'domain_context';
+      const updated = { type: docType, name: 'Domain Context' };
 
-      const { client } = await bootMcpPair({
+      const { client, fetchSpy } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { [`GET /v1/projects/${projectId}/backlog`]: { data: items, nextCursor: null } },
+        routes: { [`PUT /v1/teams/${teamId}/documents/${docType}/draft`]: { data: updated } },
       });
 
-      const result = await client.callTool({
-        name: 'taiga_list_backlog_items',
-        arguments: { projectId },
+      await client.callTool({
+        name: 'taiga_update_team_document',
+        arguments: { teamId, type: docType, data: { sections: { overview: 'Updated' } } },
       });
 
-      expect(parseToolResult(result)).toEqual(items);
+      const putCall = fetchSpy.mock.calls.find(
+        (c: unknown[]) => (c[1] as RequestInit)?.method === 'PUT' && (c[0] as string).includes('/teams/')
+      );
+      expect(putCall).toBeDefined();
+      expect(putCall![0]).toContain(`/v1/teams/${teamId}/documents/${docType}/draft`);
     });
 
     it('should return skills through MCP protocol', async () => {