snboard-mcp 1.0.4 → 1.1.0

package/dist/index.js

@@ -32,52 +32,83 @@ var kanbanApi = {
   createFolder: (data) => api("/api/folders", { method: "POST", body: JSON.stringify(data) }),
   updateFolder: (id, data) => api(`/api/folders/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
   deleteFolder: (id) => api(`/api/folders/${id}`, { method: "DELETE" }),
-  moveProjectToFolder: (projectId, folderId) => api(`/api/projects/${projectId}`, { method: "PATCH", body: JSON.stringify({ folderId }) }),
+  moveProjectToFolder: (projectId, folderId) => api(`/api/projects/${projectId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ folderId })
+  }),
+  reorderFolders: (folderId, targetFolderId) => api("/api/folders/reorder", {
+    method: "POST",
+    body: JSON.stringify({ folderId, targetFolderId })
+  }),
   // Projects
   listProjects: (params) => {
     const searchParams = new URLSearchParams();
     if (params?.folderId) searchParams.set("folderId", params.folderId);
-    if (params?.limit) searchParams.set("limit", params.limit.toString());
+    searchParams.set("limit", (params?.limit || 20).toString());
     if (params?.compact) searchParams.set("compact", "true");
     const query = searchParams.toString();
     return api(`/api/projects${query ? `?${query}` : ""}`);
   },
   createProject: (data) => api("/api/projects", { method: "POST", body: JSON.stringify(data) }),
-  getProject: (id) => api(`/api/projects/${id}`),
-  updateProject: (id, data) => api(`/api/projects/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  getProject: (id, params) => {
+    const searchParams = new URLSearchParams();
+    if (params?.includeBoards) searchParams.set("includeBoards", "true");
+    if (params?.boardsCompact) searchParams.set("boardsCompact", "true");
+    const query = searchParams.toString();
+    return api(`/api/projects/${id}${query ? `?${query}` : ""}`);
+  },
+  updateProject: (id, data) => api(`/api/projects/${id}`, { method: "PUT", body: JSON.stringify(data) }),
   deleteProject: (id) => api(`/api/projects/${id}`, { method: "DELETE" }),
+  reorderProjects: (projectId, targetProjectId, folderId) => api("/api/projects/reorder", {
+    method: "POST",
+    body: JSON.stringify({ projectId, targetProjectId, folderId })
+  }),
   // Boards
-  listBoards: (projectId, params) => {
+  listBoards: (params) => {
     const searchParams = new URLSearchParams();
-    searchParams.set("projectId", projectId);
-    if (params?.compact) searchParams.set("compact", "true");
+    if (params?.projectId) searchParams.set("projectId", params.projectId);
     if (params?.limit) searchParams.set("limit", params.limit.toString());
-    return api(`/api/boards?${searchParams.toString()}`);
+    if (params?.compact) searchParams.set("compact", "true");
+    const query = searchParams.toString();
+    return api(`/api/boards${query ? `?${query}` : ""}`);
   },
   createBoard: (data) => api("/api/boards", { method: "POST", body: JSON.stringify(data) }),
   getBoard: (id, params) => {
     const searchParams = new URLSearchParams();
     if (params?.columnId) searchParams.set("columnId", params.columnId);
-    if (params?.includeCards) searchParams.set("includeCards", "true");
+    if (params?.includeCards) {
+      searchParams.set("includeCards", "true");
+      searchParams.set("cardLimit", (params?.cardLimit || 10).toString());
+    }
     if (params?.includeTags) searchParams.set("includeTags", "true");
     if (params?.includeComments) searchParams.set("includeComments", "true");
-    if (params?.cardLimit) searchParams.set("cardLimit", params.cardLimit.toString());
     if (params?.compact) searchParams.set("compact", "true");
     if (params?.priority) searchParams.set("priority", params.priority);
     const query = searchParams.toString();
     return api(`/api/boards/${id}${query ? `?${query}` : ""}`);
   },
-  updateBoard: (id, data) => api(`/api/boards/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  updateBoard: (id, data) => api(`/api/boards/${id}`, { method: "PUT", body: JSON.stringify(data) }),
   deleteBoard: (id) => api(`/api/boards/${id}`, { method: "DELETE" }),
   // Columns
   createColumn: (data) => api("/api/columns", { method: "POST", body: JSON.stringify(data) }),
-  updateColumn: (id, data) => api(`/api/columns/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  updateColumn: (id, data) => api(`/api/columns/${id}`, { method: "PUT", body: JSON.stringify(data) }),
   deleteColumn: (id) => api(`/api/columns/${id}`, { method: "DELETE" }),
+  reorderColumns: (columns) => api("/api/columns/reorder", {
+    method: "POST",
+    body: JSON.stringify({ columns })
+  }),
   // Cards
+  getCard: (id) => api(`/api/cards/${id}`),
   createCard: (data) => api("/api/cards", { method: "POST", body: JSON.stringify(data) }),
-  updateCard: (id, data) => api(`/api/cards/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  updateCard: (id, data) => api(`/api/cards/${id}`, { method: "PUT", body: JSON.stringify(data) }),
   deleteCard: (id) => api(`/api/cards/${id}`, { method: "DELETE" }),
-  moveCard: (id, targetColumnId) => api("/api/cards/move", { method: "POST", body: JSON.stringify({ cardId: id, targetColumnId }) }),
+  archiveCard: (id) => api(`/api/cards/${id}`, { method: "PUT", body: JSON.stringify({ isArchived: true }) }),
+  unarchiveCard: (id) => api(`/api/cards/${id}`, { method: "PUT", body: JSON.stringify({ isArchived: false }) }),
+  listArchivedCards: (boardId) => api(`/api/archived?boardId=${boardId}`),
+  moveCard: (id, targetColumnId, newOrder) => api("/api/cards/move", {
+    method: "POST",
+    body: JSON.stringify({ cardId: id, targetColumnId, ...newOrder !== void 0 && { newOrder } })
+  }),
   getBranchName: (id, type) => api(`/api/cards/${id}/branch?type=${type}`),
   searchCards: (params) => {
     const searchParams = new URLSearchParams();
@@ -87,139 +118,1545 @@ var kanbanApi = {
     if (params.columnId) searchParams.set("columnId", params.columnId);
     if (params.epicId) searchParams.set("epicId", params.epicId);
     if (params.featureId) searchParams.set("featureId", params.featureId);
-    if (params.hasEpic !== void 0) searchParams.set("hasEpic", params.hasEpic.toString());
+    if (params.hasEpic !== void 0)
+      searchParams.set("hasEpic", params.hasEpic.toString());
     if (params.status) searchParams.set("status", params.status);
-    if (params.tagIds?.length) searchParams.set("tagIds", params.tagIds.join(","));
-    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.tagIds?.length)
+      searchParams.set("tagIds", params.tagIds.join(","));
+    searchParams.set("limit", (params.limit || 20).toString());
     if (params.compact) searchParams.set("compact", "true");
     return api(`/api/search?${searchParams.toString()}`);
   },
+  // Tags - managed via card update with tagIds
+  addTagToCard: async (cardId, tagId) => {
+    const card = await api(`/api/cards/${cardId}`);
+    const currentTagIds = (card.tags || []).map((t) => t.id);
+    if (!currentTagIds.includes(tagId)) {
+      currentTagIds.push(tagId);
+    }
+    return api(`/api/cards/${cardId}`, {
+      method: "PUT",
+      body: JSON.stringify({ tagIds: currentTagIds })
+    });
+  },
+  removeTagFromCard: async (cardId, tagId) => {
+    const card = await api(`/api/cards/${cardId}`);
+    const currentTagIds = (card.tags || []).map((t) => t.id).filter((id) => id !== tagId);
+    return api(`/api/cards/${cardId}`, {
+      method: "PUT",
+      body: JSON.stringify({ tagIds: currentTagIds })
+    });
+  },
+  // Bulk Operations
+  bulkCreateCards: async (data) => {
+    const results = await Promise.all(
+      data.cards.map(
+        (card) => api("/api/cards", {
+          method: "POST",
+          body: JSON.stringify({ columnId: data.columnId, ...card })
+        })
+      )
+    );
+    return { created: results.length, cards: results };
+  },
+  bulkCreateEpicWithCards: async (data) => {
+    const epic = await api("/api/epics", {
+      method: "POST",
+      body: JSON.stringify(data.epic)
+    });
+    const cardResults = await Promise.all(
+      data.cards.map(
+        (card) => api("/api/cards", {
+          method: "POST",
+          body: JSON.stringify({
+            columnId: data.columnId,
+            epicId: epic.id,
+            ...card
+          })
+        })
+      )
+    );
+    return { epic, cards: cardResults, created: cardResults.length };
+  },
+  bulkCreateEpicWithFeatures: async (data) => {
+    const epic = await api("/api/epics", { method: "POST", body: JSON.stringify(data.epic) });
+    const features = await Promise.all(
+      data.features.map(
+        (f) => api("/api/features", {
+          method: "POST",
+          body: JSON.stringify({ epicId: epic.id, title: f.title, slug: f.slug, description: f.description })
+        })
+      )
+    );
+    const featureResults = await Promise.all(
+      features.map(async (feature, i) => {
+        const featureCards = data.features[i].cards;
+        const cards = await Promise.all(
+          featureCards.map(
+            (c) => api("/api/cards", {
+              method: "POST",
+              body: JSON.stringify({ ...c, epicId: epic.id })
+            })
+          )
+        );
+        for (const card of cards) {
+          await api(`/api/features/${feature.id}/cards`, {
+            method: "POST",
+            body: JSON.stringify({ cardId: card.id })
+          });
+        }
+        return { id: feature.id, slug: feature.slug, title: feature.title, cardIds: cards.map((c) => c.id) };
+      })
+    );
+    const totalCards = featureResults.reduce((sum, f) => sum + f.cardIds.length, 0);
+    return {
+      epic: { id: epic.id, slug: epic.slug, name: epic.name },
+      features: featureResults,
+      total: { features: features.length, cards: totalCards }
+    };
+  },
+  bulkMoveCards: async (data) => {
+    const results = await Promise.all(
+      data.cardIds.map(
+        (cardId) => api("/api/cards/move", {
+          method: "POST",
+          body: JSON.stringify({ cardId, targetColumnId: data.targetColumnId })
+        })
+      )
+    );
+    return { moved: results.length };
+  },
+  // Aggregated views
+  getWorkspace: async (projectId) => {
+    const project = await api(
+      `/api/projects/${projectId}?includeBoards=true&boardsCompact=true`
+    );
+    if (!project.boards?.length) return { project, boards: [] };
+    const boardsWithColumns = await Promise.all(
+      project.boards.map((b) => api(`/api/boards/${b.id}`))
+    );
+    return {
+      project: { id: project.id, name: project.name },
+      boards: boardsWithColumns
+    };
+  },
+  getBoardSummary: async (boardId) => {
+    const board = await api(
+      `/api/boards/${boardId}?includeCards=true&compact=true`
+    );
+    const summary = {
+      id: board.id,
+      name: board.name,
+      columns: board.columns.map((col) => ({
+        id: col.id,
+        name: col.name,
+        cardCount: col.cards?.length || 0,
+        p1Count: col.cards?.filter((c) => c.priority === "P1").length || 0,
+        p2Count: col.cards?.filter((c) => c.priority === "P2").length || 0,
+        p3Count: col.cards?.filter((c) => c.priority === "P3").length || 0
+      })),
+      totalCards: board.columns.reduce(
+        (sum, col) => sum + (col.cards?.length || 0),
+        0
+      )
+    };
+    return summary;
+  },
+  getEpicSummary: async (epicId) => {
+    const epic = await api(`/api/epics/${epicId}`);
+    const cards = epic.cards || [];
+    const todoCards = cards.filter(
+      (c) => c.column?.name?.toLowerCase().includes("todo") || c.column?.name?.toLowerCase().includes("to do")
+    );
+    const inProgressCards = cards.filter(
+      (c) => c.column?.name?.toLowerCase().includes("progress")
+    );
+    const doneCards = cards.filter(
+      (c) => c.column?.name?.toLowerCase().includes("done")
+    );
+    return {
+      id: epic.id,
+      slug: epic.slug,
+      name: epic.name,
+      status: epic.status,
+      stats: {
+        total: cards.length,
+        todo: todoCards.length,
+        inProgress: inProgressCards.length,
+        done: doneCards.length,
+        progress: cards.length ? Math.round(doneCards.length / cards.length * 100) : 0
+      },
+      cards: cards.map((c) => ({
+        id: c.id,
+        title: c.title,
+        priority: c.priority,
+        status: c.column?.name
+      }))
+    };
+  },
+  quickAddCards: async (data) => {
+    const lines = data.text.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+    const cards = [];
+    for (const line of lines) {
+      let title = line.replace(/^[-*]\s*/, "");
+      let priority = data.defaultPriority;
+      const priorityMatch = title.match(/^(?:\[?(P[123])\]?:?\s*)/i);
+      if (priorityMatch) {
+        priority = priorityMatch[1].toUpperCase();
+        title = title.slice(priorityMatch[0].length);
+      }
+      if (title) cards.push({ title, priority });
+    }
+    if (!cards.length) return { created: 0, cards: [] };
+    const results = await Promise.all(
+      cards.map(
+        (card) => api("/api/cards", {
+          method: "POST",
+          body: JSON.stringify({ columnId: data.columnId, ...card })
+        })
+      )
+    );
+    return { created: results.length, cards: results };
+  },
+  moveCardsByColumn: async (data) => {
+    const searchResult = await api(
+      `/api/search?query=*&columnId=${data.sourceColumnId}&limit=${data.limit || 50}&compact=true`
+    );
+    const cards = Array.isArray(searchResult) ? searchResult : searchResult.cards || [];
+    if (!cards.length) return { moved: 0 };
+    await Promise.all(
+      cards.map(
+        (c) => api("/api/cards/move", {
+          method: "POST",
+          body: JSON.stringify({
+            cardId: c.id,
+            targetColumnId: data.targetColumnId
+          })
+        })
+      )
+    );
+    return { moved: cards.length };
+  },
   // Comments
-  addComment: (cardId, content) => api("/api/comments", { method: "POST", body: JSON.stringify({ cardId, content }) }),
+  addComment: (cardId, content) => api("/api/comments", {
+    method: "POST",
+    body: JSON.stringify({ cardId, content })
+  }),
+  deleteComment: (commentId) => api(`/api/comments?id=${commentId}`, { method: "DELETE" }),
   // Checklists
   createChecklist: (data) => api("/api/checklists", { method: "POST", body: JSON.stringify(data) }),
   updateChecklist: (id, data) => api(`/api/checklists/${id}`, { method: "PUT", body: JSON.stringify(data) }),
   deleteChecklist: (id) => api(`/api/checklists/${id}`, { method: "DELETE" }),
   // Checklist Items
   createChecklistItem: (data) => api("/api/checklist-items", { method: "POST", body: JSON.stringify(data) }),
-  updateChecklistItem: (id, data) => api(`/api/checklist-items/${id}`, { method: "PUT", body: JSON.stringify(data) }),
+  updateChecklistItem: (id, data) => api(`/api/checklist-items/${id}`, {
+    method: "PUT",
+    body: JSON.stringify(data)
+  }),
   deleteChecklistItem: (id) => api(`/api/checklist-items/${id}`, { method: "DELETE" }),
   // Tags
   listTags: () => api("/api/tags"),
   createTag: (data) => api("/api/tags", { method: "POST", body: JSON.stringify(data) }),
-  deleteTag: (id) => api(`/api/tags/${id}`, { method: "DELETE" }),
-  addTagToCard: (cardId, tagId) => api(`/api/cards/${cardId}/tags`, { method: "POST", body: JSON.stringify({ tagId }) }),
-  removeTagFromCard: (cardId, tagId) => api(`/api/cards/${cardId}/tags/${tagId}`, { method: "DELETE" }),
+  deleteTag: (id) => api(`/api/tags?id=${id}`, { method: "DELETE" }),
   // Epics
   listEpics: (params) => {
     const searchParams = new URLSearchParams();
     if (params?.status) searchParams.set("status", params.status);
-    if (params?.includeProgress === false) searchParams.set("includeProgress", "false");
-    if (params?.limit) searchParams.set("limit", params.limit.toString());
+    if (params?.includeProgress === false)
+      searchParams.set("includeProgress", "false");
+    searchParams.set("limit", (params?.limit || 15).toString());
     if (params?.compact) searchParams.set("compact", "true");
     const query = searchParams.toString();
     return api(`/api/epics${query ? `?${query}` : ""}`);
   },
   createEpic: (data) => api("/api/epics", { method: "POST", body: JSON.stringify(data) }),
+  updateEpic: (id, data) => api(`/api/epics/${id}`, { method: "PUT", body: JSON.stringify(data) }),
   getEpic: (id) => api(`/api/epics/${id}`),
-  updateEpic: (id, data) => api(`/api/epics/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
   deleteEpic: (id) => api(`/api/epics/${id}`, { method: "DELETE" }),
-  addCardToEpic: (epicId, cardId) => api(`/api/epics/${epicId}/cards`, { method: "POST", body: JSON.stringify({ cardId }) }),
+  addCardToEpic: (epicId, cardId) => api(`/api/epics/${epicId}/cards`, {
+    method: "POST",
+    body: JSON.stringify({ cardId })
+  }),
   removeCardFromEpic: (epicId, cardId) => api(`/api/epics/${epicId}/cards/${cardId}`, { method: "DELETE" }),
-  getEpicTimeline: () => api("/api/epics/timeline"),
+  // Features
+  listFeatures: (epicId) => {
+    const query = epicId ? `?epicId=${epicId}` : "";
+    return api(`/api/features${query}`);
+  },
+  getFeature: (id) => api(`/api/features/${id}`),
+  getActiveFeatures: () => api("/api/features/active"),
+  createFeature: (data) => api("/api/features", { method: "POST", body: JSON.stringify(data) }),
+  updateFeature: (id, data) => api(`/api/features/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  deleteFeature: (id) => api(`/api/features/${id}`, { method: "DELETE" }),
+  addCardToFeature: (featureId, cardId) => api(`/api/features/${featureId}/cards`, { method: "POST", body: JSON.stringify({ cardId }) }),
+  removeCardFromFeature: (featureId, cardId) => api(`/api/features/${featureId}/cards/${cardId}`, { method: "DELETE" }),
+  getFeatureCards: (featureId) => api(`/api/features/${featureId}/cards`),
   // Card Links
-  linkCards: (cardId1, cardId2, label) => api("/api/card-links", { method: "POST", body: JSON.stringify({ cardId1, cardId2, label }) }),
-  unlinkCards: (cardId1, cardId2) => api("/api/card-links", { method: "DELETE", body: JSON.stringify({ cardId1, cardId2 }) }),
+  linkCards: (cardId1, cardId2, label) => api("/api/card-links", {
+    method: "POST",
+    body: JSON.stringify({ fromCardId: cardId1, toCardId: cardId2, label })
+  }),
+  unlinkCards: (linkId) => api(`/api/card-links?id=${linkId}`, { method: "DELETE" }),
   getLinkedCards: (cardId) => api(`/api/card-links?cardId=${cardId}`),
-  getFeatureCards: (cardId) => api(`/api/features?cardId=${cardId}`),
-  // GitHub Integration
-  setupGithubIntegration: (data) => api("/api/github/integration", { method: "POST", body: JSON.stringify(data) }),
-  getGithubIntegration: (projectId) => api(`/api/github/integration?projectId=${projectId}`),
-  updateGithubIntegration: (projectId, data) => api(`/api/github/integration/${projectId}`, { method: "PATCH", body: JSON.stringify(data) }),
-  removeGithubIntegration: (projectId) => api(`/api/github/integration/${projectId}`, { method: "DELETE" }),
-  linkCardToBranch: (cardId, branch) => api(`/api/cards/${cardId}`, { method: "PATCH", body: JSON.stringify({ githubBranch: branch }) }),
-  linkCardToPr: (cardId, prUrl) => api(`/api/cards/${cardId}`, { method: "PATCH", body: JSON.stringify({ githubPrUrl: prUrl }) }),
+  // GitHub Integration - routes at /api/projects/[id]/github
+  setupGithubIntegration: (data) => api(`/api/projects/${data.projectId}/github`, {
+    method: "POST",
+    body: JSON.stringify(data)
+  }),
+  getGithubIntegration: (projectId) => api(`/api/projects/${projectId}/github`),
+  updateGithubIntegration: (projectId, data) => api(`/api/projects/${projectId}/github`, {
+    method: "PUT",
+    body: JSON.stringify(data)
+  }),
+  removeGithubIntegration: (projectId) => api(`/api/projects/${projectId}/github`, { method: "DELETE" }),
+  linkCardToBranch: (cardId, branch) => api(`/api/cards/${cardId}`, {
+    method: "PUT",
+    body: JSON.stringify({ githubBranch: branch })
+  }),
+  linkCardToPr: (cardId, prUrl) => api(`/api/cards/${cardId}`, {
+    method: "PUT",
+    body: JSON.stringify({ githubPrUrl: prUrl })
+  }),
   // GitHub API
   githubListRepos: (userId, type) => api(`/api/github/repos?userId=${userId}${type ? `&type=${type}` : ""}`),
   githubCreateBranch: (data) => api("/api/github/branches", { method: "POST", body: JSON.stringify(data) }),
-  githubCreatePr: (data) => api("/api/github/pull-requests", { method: "POST", body: JSON.stringify(data) }),
-  githubAutoSetupWebhook: (data) => api("/api/github/webhooks/auto-setup", { method: "POST", body: JSON.stringify(data) })
+  githubCreatePr: (data) => api("/api/github/pull-requests", {
+    method: "POST",
+    body: JSON.stringify(data)
+  }),
+  // Ideas
+  listIdeas: (params) => {
+    const searchParams = new URLSearchParams();
+    if (params?.status) searchParams.set("status", params.status);
+    if (params?.filter) searchParams.set("filter", params.filter);
+    const query = searchParams.toString();
+    return api(`/api/ideas${query ? `?${query}` : ""}`);
+  },
+  getIdea: (id) => api(`/api/ideas/${id}`),
+  createIdea: (data) => api("/api/ideas", { method: "POST", body: JSON.stringify(data) }),
+  updateIdea: (id, data) => api(`/api/ideas/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  deleteIdea: (id) => api(`/api/ideas/${id}`, { method: "DELETE" }),
+  convertIdeaToCard: (ideaId, data) => api(`/api/ideas/${ideaId}/convert`, { method: "POST", body: JSON.stringify(data) }),
+  // Time Tracking
+  getTimeTracking: (params) => {
+    const searchParams = new URLSearchParams();
+    if (params?.startDate) searchParams.set("startDate", params.startDate);
+    if (params?.endDate) searchParams.set("endDate", params.endDate);
+    if (params?.projectId) searchParams.set("projectId", params.projectId);
+    const query = searchParams.toString();
+    return api(`/api/time-tracking${query ? `?${query}` : ""}`);
+  },
+  logActivity: (data) => api("/api/time-tracking", { method: "POST", body: JSON.stringify(data) }),
+  endTimeSession: () => api("/api/time-tracking", { method: "DELETE" }),
+  // Daily Summary
+  getDailySummary: () => api("/api/daily-summary"),
+  // Retrospective
+  getRetrospective: (days) => api(`/api/retrospectives/weekly${days ? `?days=${days}` : ""}`),
+  // Export
+  exportBoard: (boardId) => api(`/api/export/board/${boardId}`),
+  exportProject: (projectId) => api(`/api/export/project/${projectId}`)
 };
 var server = new Server(
-  { name: "kanban-mcp", version: "1.0.0" },
+  { name: "kanban-mcp", version: "1.1.0" },
   { capabilities: { tools: {} } }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
     // FOLDERS
-    { name: "list_folders", description: "List all folders with their projects", inputSchema: { type: "object", properties: {} } },
-    { name: "create_folder", description: "Create a new folder to organize projects", inputSchema: { type: "object", properties: { name: { type: "string", description: "Folder name" }, icon: { type: "string", description: "Folder icon (optional)" }, color: { type: "string", description: "Folder color hex (optional)" } }, required: ["name"] } },
-    { name: "update_folder", description: "Update a folder (name, icon, color)", inputSchema: { type: "object", properties: { folderId: { type: "string", description: "Folder ID" }, name: { type: "string" }, icon: { type: "string" }, color: { type: "string" } }, required: ["folderId"] } },
-    { name: "delete_folder", description: "Delete a folder (projects inside become orphans, not deleted)", inputSchema: { type: "object", properties: { folderId: { type: "string", description: "Folder ID" } }, required: ["folderId"] } },
-    { name: "move_project_to_folder", description: "Move a project to a folder (or remove from folder if folderId is null)", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" }, folderId: { type: "string", description: "Target folder ID (or null)" } }, required: ["projectId"] } },
+    {
+      name: "list_folders",
+      description: "List all folders with their projects",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "create_folder",
+      description: "Create a new folder to organize projects",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          icon: { type: "string" },
+          color: { type: "string" }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "update_folder",
+      description: "Update a folder (name, icon, color)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          folderId: { type: "string" },
+          name: { type: "string" },
+          icon: { type: "string" },
+          color: { type: "string" }
+        },
+        required: ["folderId"]
+      }
+    },
+    {
+      name: "delete_folder",
+      description: "Delete a folder (projects become orphans)",
+      inputSchema: {
+        type: "object",
+        properties: { folderId: { type: "string" } },
+        required: ["folderId"]
+      }
+    },
+    {
+      name: "move_project_to_folder",
+      description: "Move project to folder (null to remove)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          folderId: { type: "string" }
+        },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "reorder_folders",
+      description: "Reorder folders by moving one before/after another",
+      inputSchema: {
+        type: "object",
+        properties: {
+          folderId: { type: "string" },
+          targetFolderId: { type: "string" }
+        },
+        required: ["folderId", "targetFolderId"]
+      }
+    },
     // PROJECTS
-    { name: "list_projects", description: "List all Kanban projects with optional filters to reduce token usage", inputSchema: { type: "object", properties: { folderId: { type: "string", description: "Filter by folder ID" }, limit: { type: "number", description: "Max results" }, compact: { type: "boolean", description: "Return minimal fields" } } } },
-    { name: "create_project", description: "Create a new Kanban project", inputSchema: { type: "object", properties: { name: { type: "string", description: "Project name" }, description: { type: "string" }, emoji: { type: "string" }, color: { type: "string" }, folderId: { type: "string" } }, required: ["name"] } },
-    { name: "get_project", description: "Get a project with its boards", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" } }, required: ["projectId"] } },
-    { name: "update_project", description: "Update a project (name, description, emoji, color)", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" }, name: { type: "string" }, description: { type: "string" }, emoji: { type: "string" }, color: { type: "string" } }, required: ["projectId"] } },
-    { name: "delete_project", description: "Delete a project and all its boards, columns, and cards", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" } }, required: ["projectId"] } },
+    {
+      name: "list_projects",
+      description: "List projects (default limit:20). Use compact:true for minimal fields",
+      inputSchema: {
+        type: "object",
+        properties: {
+          folderId: { type: "string", description: 'Filter by folder. Use "none" for orphan projects' },
+          limit: { type: "number" },
+          compact: { type: "boolean" }
+        }
+      }
+    },
+    {
+      name: "create_project",
+      description: "Create a new project",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          emoji: { type: "string" },
+          color: { type: "string" },
+          folderId: { type: "string" }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "get_project",
+      description: "Get project. Use includeBoards:true to get boards in 1 call",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          includeBoards: { type: "boolean" },
+          boardsCompact: { type: "boolean" }
+        },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "update_project",
+      description: "Update project",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          name: { type: "string" },
+          description: { type: "string" },
+          emoji: { type: "string" },
+          color: { type: "string" },
+          folderId: { type: "string", description: "Move to folder (null to remove)" }
+        },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "delete_project",
+      description: "Delete project and all its content",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" } },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "reorder_projects",
+      description: "Reorder projects within a folder",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          targetProjectId: { type: "string" },
+          folderId: { type: "string", description: "Folder context (null for orphans)" }
+        },
+        required: ["projectId", "targetProjectId"]
+      }
+    },
     // BOARDS
-    { name: "list_boards", description: "List boards for a project with optional filters to reduce token usage", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" }, compact: { type: "boolean" }, includeColumnStats: { type: "boolean" }, limit: { type: "number" } }, required: ["projectId"] } },
-    { name: "create_board", description: "Create a new board in a project with default columns (To Do, In Progress, Done)", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" }, name: { type: "string", description: "Board name" } }, required: ["projectId", "name"] } },
-    { name: "get_board", description: "Get board with columns. Cards NOT included by default. Use includeCards:true + cardLimit + columnId to get specific cards.", inputSchema: { type: "object", properties: { boardId: { type: "string", description: "Board ID" }, columnId: { type: "string", description: "Get only this column" }, includeCards: { type: "boolean", description: "Include cards (default: false)" }, cardLimit: { type: "number", description: "Max cards per column (e.g. 5)" }, priority: { type: "string", enum: ["P1", "P2", "P3"], description: "Filter by priority" }, compact: { type: "boolean", description: "Minimal fields (id, title, priority)" }, includeTags: { type: "boolean", description: "Include tags" }, includeComments: { type: "boolean", description: "Include comments (max 5)" } }, required: ["boardId"] } },
-    { name: "update_board", description: "Update a board (rename)", inputSchema: { type: "object", properties: { boardId: { type: "string", description: "Board ID" }, name: { type: "string", description: "New board name" } }, required: ["boardId", "name"] } },
-    { name: "delete_board", description: "Delete a board and all its columns and cards", inputSchema: { type: "object", properties: { boardId: { type: "string", description: "Board ID" } }, required: ["boardId"] } },
+    {
+      name: "list_boards",
+      description: "List boards for a project",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          limit: { type: "number" },
+          compact: { type: "boolean" }
+        },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "create_board",
+      description: "Create board with default columns",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" }, name: { type: "string" } },
+        required: ["projectId", "name"]
+      }
+    },
+    {
+      name: "get_board",
+      description: "Get board with columns. Cards NOT included by default. Use includeCards:true + cardLimit + columnId to get specific cards.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          boardId: { type: "string" },
+          columnId: { type: "string", description: "Get only this column" },
+          includeCards: {
+            type: "boolean",
+            description: "Include cards (default: false)"
+          },
+          cardLimit: {
+            type: "number",
+            description: "Max cards per column (e.g. 5)"
+          },
+          priority: { type: "string", enum: ["P1", "P2", "P3"] },
+          compact: {
+            type: "boolean",
+            description: "Minimal fields (id, title, priority)"
+          },
+          includeTags: { type: "boolean" },
+          includeComments: {
+            type: "boolean",
+            description: "Include comments (max 5)"
+          }
+        },
+        required: ["boardId"]
+      }
+    },
+    {
+      name: "update_board",
+      description: "Rename a board",
+      inputSchema: {
+        type: "object",
+        properties: { boardId: { type: "string" }, name: { type: "string" } },
+        required: ["boardId", "name"]
+      }
+    },
+    {
+      name: "delete_board",
+      description: "Delete board and all content",
+      inputSchema: {
+        type: "object",
+        properties: { boardId: { type: "string" } },
+        required: ["boardId"]
+      }
+    },
     // COLUMNS
-    { name: "create_column", description: "Create a new column in a board", inputSchema: { type: "object", properties: { boardId: { type: "string", description: "Board ID" }, name: { type: "string", description: "Column name" }, emoji: { type: "string" } }, required: ["boardId", "name"] } },
-    { name: "update_column", description: "Update a column (name, emoji)", inputSchema: { type: "object", properties: { columnId: { type: "string", description: "Column ID" }, name: { type: "string" }, emoji: { type: "string" } }, required: ["columnId"] } },
-    { name: "delete_column", description: "Delete a column and all its cards", inputSchema: { type: "object", properties: { columnId: { type: "string", description: "Column ID" } }, required: ["columnId"] } },
+    {
+      name: "create_column",
+      description: "Create column in board",
+      inputSchema: {
+        type: "object",
+        properties: {
+          boardId: { type: "string" },
+          name: { type: "string" },
+          emoji: { type: "string" }
+        },
+        required: ["boardId", "name"]
+      }
+    },
+    {
+      name: "update_column",
+      description: "Update column",
+      inputSchema: {
+        type: "object",
+        properties: {
+          columnId: { type: "string" },
+          name: { type: "string" },
+          emoji: { type: "string" }
+        },
+        required: ["columnId"]
+      }
+    },
+    {
+      name: "delete_column",
+      description: "Delete column and cards",
+      inputSchema: {
+        type: "object",
+        properties: { columnId: { type: "string" } },
+        required: ["columnId"]
+      }
+    },
+    {
+      name: "reorder_columns",
+      description: "Reorder columns in a board",
+      inputSchema: {
+        type: "object",
+        properties: {
+          columns: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                order: { type: "number" }
+              },
+              required: ["id", "order"]
+            }
+          }
+        },
+        required: ["columns"]
+      }
+    },
     // CARDS
-    { name: "create_card", description: 'Create a new card in a column. Supports auto-assign to epic if title starts with [SLUG] or SLUG -. Use featureId for multi-project features (e.g., "AUTH", "PAYMENT").', inputSchema: { type: "object", properties: { columnId: { type: "string", description: "Column ID" }, title: { type: "string", description: "Card title" }, description: { type: "string" }, priority: { type: "string", enum: ["P1", "P2", "P3"] }, featureId: { type: "string", description: 'Shared feature ID for multi-project features (e.g., "AUTH", "PAYMENT")' }, dueDate: { type: "string" }, epicId: { type: "string" }, tagIds: { type: "array", items: { type: "string" } }, linkedCardIds: { type: "array", items: { type: "string" } }, linkLabel: { type: "string" } }, required: ["columnId", "title"] } },
-    { name: "update_card", description: "Update an existing card (title, description, priority, featureId, dueDate)", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, title: { type: "string" }, description: { type: "string" }, priority: { type: "string", enum: ["P1", "P2", "P3"] }, featureId: { type: "string", description: 'Shared feature ID for multi-project features (e.g., "AUTH", "PAYMENT")' }, dueDate: { type: "string" } }, required: ["cardId"] } },
-    { name: "delete_card", description: "Delete a card", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" } }, required: ["cardId"] } },
-    { name: "move_card", description: "Move a card to a different column", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, targetColumnId: { type: "string", description: "Target column ID" } }, required: ["cardId", "targetColumnId"] } },
-    { name: "add_comment", description: "Add a comment to a card", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, content: { type: "string", description: "Comment content" } }, required: ["cardId", "content"] } },
+    {
+      name: "get_card",
+      description: "Get a card with all details (tags, comments, checklists, epics, features)",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" } },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "create_card",
+      description: "Create card. Auto-assign to epic if epicId provided.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          columnId: { type: "string" },
+          title: { type: "string" },
+          description: { type: "string" },
+          priority: { type: "string", enum: ["P1", "P2", "P3"] },
+          dueDate: { type: "string" },
+          epicId: { type: "string" },
+          tagIds: { type: "array", items: { type: "string" } },
+          estimatedMinutes: { type: "number", description: "Estimated time in minutes" },
+          cognitiveLoad: { type: "string", description: "Cognitive load level" }
+        },
+        required: ["columnId", "title"]
+      }
+    },
+    {
+      name: "update_card",
+      description: "Update card fields",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardId: { type: "string" },
+          title: { type: "string" },
+          description: { type: "string" },
+          priority: { type: "string", enum: ["P1", "P2", "P3"] },
+          dueDate: { type: "string" },
+          tagIds: { type: "array", items: { type: "string" }, description: "Replace all tags with these IDs" },
+          cognitiveLoad: { type: "string" },
+          estimatedMinutes: { type: "number" },
+          githubBranch: { type: "string" },
+          githubPrUrl: { type: "string" },
+          isArchived: { type: "boolean" }
+        },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "delete_card",
+      description: "Delete a card",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" } },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "archive_card",
+      description: "Archive a card",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" } },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "unarchive_card",
+      description: "Unarchive a card (restore from archive)",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" } },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "list_archived_cards",
+      description: "List archived cards for a board",
+      inputSchema: {
+        type: "object",
+        properties: { boardId: { type: "string" } },
+        required: ["boardId"]
+      }
+    },
+    {
+      name: "move_card",
+      description: "Move card to column. Use newOrder for specific positioning.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardId: { type: "string" },
+          targetColumnId: { type: "string" },
+          newOrder: { type: "number", description: "Position in target column (0-indexed, default: end)" }
+        },
+        required: ["cardId", "targetColumnId"]
+      }
+    },
+    {
+      name: "add_comment",
+      description: "Add comment to card",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" }, content: { type: "string" } },
+        required: ["cardId", "content"]
+      }
+    },
+    {
+      name: "delete_comment",
+      description: "Delete a comment",
+      inputSchema: {
+        type: "object",
+        properties: { commentId: { type: "string" } },
+        required: ["commentId"]
+      }
+    },
     // CHECKLISTS
-    { name: "create_checklist", description: "Create a new checklist on a card", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, title: { type: "string", description: "Checklist title" } }, required: ["cardId", "title"] } },
-    { name: "update_checklist", description: "Update a checklist title", inputSchema: { type: "object", properties: { checklistId: { type: "string", description: "Checklist ID" }, title: { type: "string", description: "New title" } }, required: ["checklistId", "title"] } },
-    { name: "delete_checklist", description: "Delete a checklist and all its items", inputSchema: { type: "object", properties: { checklistId: { type: "string", description: "Checklist ID" } }, required: ["checklistId"] } },
-    { name: "create_checklist_item", description: "Add an item to a checklist", inputSchema: { type: "object", properties: { checklistId: { type: "string", description: "Checklist ID" }, content: { type: "string", description: "Item content" } }, required: ["checklistId", "content"] } },
-    { name: "update_checklist_item", description: "Update a checklist item (content or completed status)", inputSchema: { type: "object", properties: { itemId: { type: "string", description: "Checklist item ID" }, content: { type: "string", description: "New content" }, completed: { type: "boolean", description: "Completed status" } }, required: ["itemId"] } },
-    { name: "delete_checklist_item", description: "Delete a checklist item", inputSchema: { type: "object", properties: { itemId: { type: "string", description: "Checklist item ID" } }, required: ["itemId"] } },
-    { name: "get_branch_name", description: "Generate a GitHub branch name for a card", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, type: { type: "string", enum: ["feature", "fix", "chore", "refactor", "docs"], description: "Branch type" } }, required: ["cardId"] } },
-    { name: "search_cards", description: "Search cards by title or description with filters to reduce token usage", inputSchema: { type: "object", properties: { query: { type: "string", description: "Search query" }, projectId: { type: "string" }, boardId: { type: "string" }, columnId: { type: "string" }, epicId: { type: "string" }, featureId: { type: "string", description: "Filter by featureId (multi-project feature)" }, hasEpic: { type: "boolean" }, status: { type: "string", enum: ["todo", "in_progress", "done"] }, tagIds: { type: "array", items: { type: "string" } }, limit: { type: "number" }, compact: { type: "boolean" } }, required: ["query"] } },
+    {
+      name: "create_checklist",
+      description: "Create checklist on card",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" }, title: { type: "string" } },
+        required: ["cardId", "title"]
+      }
+    },
+    {
+      name: "update_checklist",
+      description: "Update checklist title",
+      inputSchema: {
+        type: "object",
+        properties: {
+          checklistId: { type: "string" },
+          title: { type: "string" }
+        },
+        required: ["checklistId", "title"]
+      }
+    },
+    {
+      name: "delete_checklist",
+      description: "Delete checklist",
+      inputSchema: {
+        type: "object",
+        properties: { checklistId: { type: "string" } },
+        required: ["checklistId"]
+      }
+    },
+    {
+      name: "create_checklist_item",
+      description: "Add checklist item",
+      inputSchema: {
+        type: "object",
+        properties: {
+          checklistId: { type: "string" },
+          content: { type: "string" }
+        },
+        required: ["checklistId", "content"]
+      }
+    },
+    {
+      name: "update_checklist_item",
+      description: "Update checklist item",
+      inputSchema: {
+        type: "object",
+        properties: {
+          itemId: { type: "string" },
+          content: { type: "string" },
+          completed: { type: "boolean" }
+        },
+        required: ["itemId"]
+      }
+    },
+    {
+      name: "delete_checklist_item",
+      description: "Delete checklist item",
+      inputSchema: {
+        type: "object",
+        properties: { itemId: { type: "string" } },
+        required: ["itemId"]
+      }
+    },
+    {
+      name: "get_branch_name",
+      description: "Generate GitHub branch name",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardId: { type: "string" },
+          type: {
+            type: "string",
+            enum: ["feature", "fix", "chore", "refactor", "docs"]
+          }
+        },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "search_cards",
+      description: "Search cards, projects and boards (default limit:20). Use compact:true for minimal fields",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string" },
+          projectId: { type: "string" },
+          boardId: { type: "string" },
+          columnId: { type: "string" },
+          epicId: { type: "string" },
+          featureId: { type: "string" },
+          hasEpic: { type: "boolean" },
+          status: { type: "string", enum: ["todo", "in_progress", "done"] },
+          tagIds: { type: "array", items: { type: "string" } },
+          limit: { type: "number" },
+          compact: { type: "boolean" }
+        },
+        required: ["query"]
+      }
+    },
+    // BULK OPERATIONS
+    {
+      name: "bulk_create_cards",
+      description: "Create multiple cards in 1 call",
+      inputSchema: {
+        type: "object",
+        properties: {
+          columnId: { type: "string" },
+          cards: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                description: { type: "string" },
+                priority: { type: "string", enum: ["P1", "P2", "P3"] },
+                epicId: { type: "string" }
+              },
+              required: ["title"]
+            }
+          }
+        },
+        required: ["columnId", "cards"]
+      }
+    },
+    {
+      name: "bulk_create_epic_with_cards",
+      description: "Create epic + all its cards in 1 call",
+      inputSchema: {
+        type: "object",
+        properties: {
+          epic: {
+            type: "object",
+            properties: {
+              slug: { type: "string" },
+              name: { type: "string" },
+              description: { type: "string" },
+              emoji: { type: "string" },
+              color: { type: "string" }
+            },
+            required: ["slug", "name"]
+          },
+          columnId: { type: "string" },
+          cards: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                description: { type: "string" },
+                priority: { type: "string", enum: ["P1", "P2", "P3"] }
+              },
+              required: ["title"]
+            }
+          }
+        },
+        required: ["epic", "columnId", "cards"]
+      }
+    },
+    {
+      name: "bulk_create_epic_with_features",
+      description: "Create epic + features + cards across projects in 1 call. Cards auto-prefixed with SLUG{N}-.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          epic: {
+            type: "object",
+            properties: {
+              slug: { type: "string" },
+              name: { type: "string" },
+              description: { type: "string" },
+              emoji: { type: "string" },
+              color: { type: "string" }
+            },
+            required: ["slug", "name"]
+          },
+          features: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                slug: { type: "string", description: "UPPERCASE slug (auto-generated from title if omitted)" },
+                description: { type: "string" },
+                cards: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      columnId: { type: "string" },
+                      title: { type: "string" },
+                      description: { type: "string" },
+                      priority: { type: "string", enum: ["P1", "P2", "P3"] }
+                    },
+                    required: ["columnId", "title"]
+                  }
+                }
+              },
+              required: ["title", "cards"]
+            }
+          }
+        },
+        required: ["epic", "features"]
+      }
+    },
+    {
+      name: "bulk_move_cards",
+      description: "Move multiple cards to column in 1 call",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardIds: { type: "array", items: { type: "string" } },
+          targetColumnId: { type: "string" }
+        },
+        required: ["cardIds", "targetColumnId"]
+      }
+    },
+    {
+      name: "quick_add_cards",
+      description: 'Create cards from multiline text. Format: "- P1: task title" per line',
+      inputSchema: {
+        type: "object",
+        properties: {
+          columnId: { type: "string" },
+          text: {
+            type: "string",
+            description: "Multiline text, 1 card per line"
+          },
+          defaultPriority: { type: "string", enum: ["P1", "P2", "P3"] }
+        },
+        required: ["columnId", "text"]
+      }
+    },
+    {
+      name: "move_cards_by_column",
+      description: "Move ALL cards from one column to another",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sourceColumnId: { type: "string" },
+          targetColumnId: { type: "string" },
+          limit: { type: "number" }
+        },
+        required: ["sourceColumnId", "targetColumnId"]
+      }
+    },
+    // AGGREGATED VIEWS
+    {
+      name: "get_workspace",
+      description: "Get project + all boards + columns in 1 call (no cards)",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" } },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "get_board_summary",
+      description: "Get board stats only: card counts per column + priority breakdown",
+      inputSchema: {
+        type: "object",
+        properties: { boardId: { type: "string" } },
+        required: ["boardId"]
+      }
+    },
+    {
+      name: "get_epic_summary",
+      description: "Get epic with minimal card info: {id,title,priority,status} + progress stats",
+      inputSchema: {
+        type: "object",
+        properties: { epicId: { type: "string" } },
+        required: ["epicId"]
+      }
+    },
     // TAGS
-    { name: "list_tags", description: "List all available tags", inputSchema: { type: "object", properties: {} } },
-    { name: "create_tag", description: "Create a new tag", inputSchema: { type: "object", properties: { name: { type: "string", description: "Tag name" }, color: { type: "string", description: "Tag color hex" } }, required: ["name", "color"] } },
-    { name: "delete_tag", description: "Delete a tag", inputSchema: { type: "object", properties: { tagId: { type: "string", description: "Tag ID" } }, required: ["tagId"] } },
-    { name: "add_tag_to_card", description: "Add a tag to a card", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, tagId: { type: "string", description: "Tag ID" } }, required: ["cardId", "tagId"] } },
-    { name: "remove_tag_from_card", description: "Remove a tag from a card", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, tagId: { type: "string", description: "Tag ID" } }, required: ["cardId", "tagId"] } },
+    {
+      name: "list_tags",
+      description: "List all tags",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "create_tag",
+      description: "Create tag",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" }, color: { type: "string" } },
+        required: ["name", "color"]
+      }
+    },
+    {
+      name: "delete_tag",
+      description: "Delete tag",
+      inputSchema: {
+        type: "object",
+        properties: { tagId: { type: "string" } },
+        required: ["tagId"]
+      }
+    },
+    {
+      name: "add_tag_to_card",
+      description: "Add tag to card",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" }, tagId: { type: "string" } },
+        required: ["cardId", "tagId"]
+      }
+    },
+    {
+      name: "remove_tag_from_card",
+      description: "Remove tag from card",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" }, tagId: { type: "string" } },
+        required: ["cardId", "tagId"]
+      }
+    },
     // EPICS
-    { name: "list_epics", description: "List all epics with optional filters to reduce token usage", inputSchema: { type: "object", properties: { status: { type: "string" }, includeProgress: { type: "boolean" }, limit: { type: "number" }, compact: { type: "boolean" } } } },
-    { name: "create_epic", description: "Create a new epic for grouping cards", inputSchema: { type: "object", properties: { slug: { type: "string", description: 'Short unique identifier (e.g., "AUTH", "PERF")' }, name: { type: "string", description: "Epic name" }, description: { type: "string" }, emoji: { type: "string" }, color: { type: "string" }, startDate: { type: "string" }, targetDate: { type: "string" } }, required: ["slug", "name"] } },
-    { name: "get_epic", description: "Get an epic with all its cards and progress", inputSchema: { type: "object", properties: { epicId: { type: "string", description: "Epic ID or slug" } }, required: ["epicId"] } },
-    { name: "update_epic", description: "Update an epic", inputSchema: { type: "object", properties: { epicId: { type: "string", description: "Epic ID" }, slug: { type: "string" }, name: { type: "string" }, description: { type: "string" }, emoji: { type: "string" }, color: { type: "string" }, status: { type: "string" }, startDate: { type: "string" }, targetDate: { type: "string" } }, required: ["epicId"] } },
-    { name: "delete_epic", description: "Delete an epic (cards are not deleted, just unlinked)", inputSchema: { type: "object", properties: { epicId: { type: "string", description: "Epic ID" } }, required: ["epicId"] } },
-    { name: "add_card_to_epic", description: "Add a card to an epic", inputSchema: { type: "object", properties: { epicId: { type: "string", description: "Epic ID or slug" }, cardId: { type: "string", description: "Card ID" } }, required: ["epicId", "cardId"] } },
-    { name: "remove_card_from_epic", description: "Remove a card from an epic", inputSchema: { type: "object", properties: { epicId: { type: "string", description: "Epic ID" }, cardId: { type: "string", description: "Card ID" } }, required: ["epicId", "cardId"] } },
-    { name: "get_epic_timeline", description: "Get timeline view of all epics with dates and progress", inputSchema: { type: "object", properties: {} } },
+    {
+      name: "list_epics",
+      description: "List epics (default limit:15)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: { type: "string" },
+          includeProgress: { type: "boolean" },
+          limit: { type: "number" },
+          compact: { type: "boolean" }
+        }
+      }
+    },
+    {
+      name: "create_epic",
+      description: "Create epic",
+      inputSchema: {
+        type: "object",
+        properties: {
+          slug: { type: "string" },
+          name: { type: "string" },
+          description: { type: "string" },
+          emoji: { type: "string" },
+          color: { type: "string" },
+          startDate: { type: "string" },
+          targetDate: { type: "string" }
+        },
+        required: ["slug", "name"]
+      }
+    },
+    {
+      name: "get_epic",
+      description: "Get an epic with all its cards, features and progress",
+      inputSchema: {
+        type: "object",
+        properties: { epicId: { type: "string" } },
+        required: ["epicId"]
+      }
+    },
+    {
+      name: "update_epic",
+      description: "Update epic. Use syncDates:true to sync targetDate to all card due dates.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          epicId: { type: "string" },
+          slug: { type: "string" },
+          name: { type: "string" },
+          description: { type: "string" },
+          emoji: { type: "string" },
+          color: { type: "string" },
+          status: { type: "string" },
+          startDate: { type: "string" },
+          targetDate: { type: "string" },
+          syncDates: { type: "boolean", description: "Sync targetDate to all card due dates" }
+        },
+        required: ["epicId"]
+      }
+    },
+    {
+      name: "delete_epic",
+      description: "Delete epic (cards unlinked)",
+      inputSchema: {
+        type: "object",
+        properties: { epicId: { type: "string" } },
+        required: ["epicId"]
+      }
+    },
+    {
+      name: "add_card_to_epic",
+      description: "Add card to epic",
+      inputSchema: {
+        type: "object",
+        properties: { epicId: { type: "string" }, cardId: { type: "string" } },
+        required: ["epicId", "cardId"]
+      }
+    },
+    {
+      name: "remove_card_from_epic",
+      description: "Remove card from epic",
+      inputSchema: {
+        type: "object",
+        properties: { epicId: { type: "string" }, cardId: { type: "string" } },
+        required: ["epicId", "cardId"]
+      }
+    },
+    // FEATURES
+    {
+      name: "list_features",
+      description: "List features. Filter by epicId or slug.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          epicId: { type: "string" },
+          slug: { type: "string", description: "Filter by feature slug (UPPERCASE)" }
+        }
+      }
+    },
+    {
+      name: "get_feature",
+      description: "Get a feature with cards and progress. Accepts featureId or featureSlug (UPPERCASE).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          featureId: { type: "string", description: "Feature ID or slug" },
+          featureSlug: { type: "string", description: "Feature slug (UPPERCASE), alternative to featureId" }
+        }
+      }
+    },
+    {
+      name: "get_active_features",
+      description: "Get features with cards in progress, organized by epic",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "create_feature",
+      description: "Create a new feature (optionally in an epic)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          epicId: { type: "string" },
+          title: { type: "string" },
+          slug: { type: "string" },
+          description: { type: "string" },
+          status: { type: "string", enum: ["planning", "in_progress", "completed", "on_hold"] }
+        },
+        required: ["title"]
+      }
+    },
+    {
+      name: "update_feature",
+      description: "Update a feature",
+      inputSchema: {
+        type: "object",
+        properties: {
+          featureId: { type: "string" },
+          title: { type: "string" },
+          slug: { type: "string" },
+          description: { type: "string" },
+          status: { type: "string", enum: ["planning", "in_progress", "completed", "on_hold"] },
+          order: { type: "number" },
+          epicId: { type: "string", description: "Move to another epic" }
+        },
+        required: ["featureId"]
+      }
+    },
+    {
+      name: "delete_feature",
+      description: "Delete a feature (cards unlinked)",
+      inputSchema: {
+        type: "object",
+        properties: { featureId: { type: "string" } },
+        required: ["featureId"]
+      }
+    },
+    {
+      name: "add_card_to_feature",
+      description: "Add a card to a feature. Accepts featureId or featureSlug.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardId: { type: "string" },
+          featureId: { type: "string", description: "Feature ID or slug" },
+          featureSlug: { type: "string", description: "Feature slug (UPPERCASE), alternative to featureId" }
+        },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "remove_card_from_feature",
+      description: "Remove a card from a feature. Accepts featureId or featureSlug.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardId: { type: "string" },
+          featureId: { type: "string", description: "Feature ID or slug" },
+          featureSlug: { type: "string", description: "Feature slug (UPPERCASE), alternative to featureId" }
+        },
+        required: ["cardId"]
+      }
+    },
+    {
+      name: "get_feature_cards",
+      description: "Get all cards in a feature. Accepts featureId or featureSlug.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          featureId: { type: "string", description: "Feature ID or slug" },
+          featureSlug: { type: "string", description: "Feature slug (UPPERCASE), alternative to featureId" }
+        }
+      }
+    },
     // CARD LINKS
-    { name: "link_cards", description: "Create a bidirectional link between two cards (for cross-project features)", inputSchema: { type: "object", properties: { cardId1: { type: "string", description: "First card ID" }, cardId2: { type: "string", description: "Second card ID" }, label: { type: "string", description: 'Link label (e.g., "depends on")' } }, required: ["cardId1", "cardId2"] } },
-    { name: "unlink_cards", description: "Remove a link between two cards", inputSchema: { type: "object", properties: { cardId1: { type: "string", description: "First card ID" }, cardId2: { type: "string", description: "Second card ID" } }, required: ["cardId1", "cardId2"] } },
-    { name: "get_linked_cards", description: "Get all cards linked to a specific card (shows cross-project relationships)", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" } }, required: ["cardId"] } },
-    { name: "get_feature_cards", description: 'Get a card and all its linked cards as a "feature bundle" with progress tracking', inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Starting card ID" } }, required: ["cardId"] } },
+    {
+      name: "link_cards",
+      description: "Link two cards",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cardId1: { type: "string" },
+          cardId2: { type: "string" },
+          label: { type: "string" }
+        },
+        required: ["cardId1", "cardId2"]
+      }
+    },
+    {
+      name: "unlink_cards",
+      description: "Unlink two cards by link ID",
+      inputSchema: {
+        type: "object",
+        properties: {
+          linkId: { type: "string" }
+        },
+        required: ["linkId"]
+      }
+    },
+    {
+      name: "get_linked_cards",
+      description: "Get linked cards",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" } },
+        required: ["cardId"]
+      }
+    },
     // GITHUB INTEGRATION
-    { name: "setup_github_integration", description: "Configure GitHub webhook integration for a project", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" }, repoOwner: { type: "string", description: "GitHub repo owner" }, repoName: { type: "string", description: "GitHub repo name" }, inProgressColumnName: { type: "string" }, doneColumnName: { type: "string" } }, required: ["projectId", "repoOwner", "repoName"] } },
-    { name: "get_github_integration", description: "Get GitHub integration settings for a project", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" } }, required: ["projectId"] } },
-    { name: "update_github_integration", description: "Update GitHub integration settings", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" }, autoMoveOnPush: { type: "boolean" }, autoMoveOnPrMerge: { type: "boolean" }, autoLinkPr: { type: "boolean" }, inProgressColumnName: { type: "string" }, doneColumnName: { type: "string" } }, required: ["projectId"] } },
-    { name: "remove_github_integration", description: "Remove GitHub integration from a project", inputSchema: { type: "object", properties: { projectId: { type: "string", description: "Project ID" } }, required: ["projectId"] } },
-    { name: "link_card_to_branch", description: "Link a card to a GitHub branch", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, branch: { type: "string", description: "GitHub branch name" } }, required: ["cardId", "branch"] } },
-    { name: "link_card_to_pr", description: "Link a card to a GitHub Pull Request", inputSchema: { type: "object", properties: { cardId: { type: "string", description: "Card ID" }, prUrl: { type: "string", description: "GitHub PR URL" } }, required: ["cardId", "prUrl"] } },
+    {
+      name: "setup_github_integration",
+      description: "Setup GitHub integration for a project (auto-creates webhook)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          repoOwner: { type: "string" },
+          repoName: { type: "string" },
+          inProgressColumnName: { type: "string" },
+          doneColumnName: { type: "string" },
+          autoMoveOnPush: { type: "boolean" },
+          autoMoveOnPrMerge: { type: "boolean" },
+          autoLinkPr: { type: "boolean" }
+        },
+        required: ["projectId", "repoOwner", "repoName"]
+      }
+    },
+    {
+      name: "get_github_integration",
+      description: "Get GitHub integration settings",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" } },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "update_github_integration",
+      description: "Update GitHub integration settings",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          repoOwner: { type: "string" },
+          repoName: { type: "string" },
+          autoMoveOnPush: { type: "boolean" },
+          autoMoveOnPrMerge: { type: "boolean" },
+          autoLinkPr: { type: "boolean" },
+          inProgressColumnName: { type: "string" },
+          doneColumnName: { type: "string" }
+        },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "remove_github_integration",
+      description: "Remove GitHub integration",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" } },
+        required: ["projectId"]
+      }
+    },
+    {
+      name: "link_card_to_branch",
+      description: "Link card to branch",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" }, branch: { type: "string" } },
+        required: ["cardId", "branch"]
+      }
+    },
+    {
+      name: "link_card_to_pr",
+      description: "Link card to PR",
+      inputSchema: {
+        type: "object",
+        properties: { cardId: { type: "string" }, prUrl: { type: "string" } },
+        required: ["cardId", "prUrl"]
+      }
+    },
     // GITHUB API
-    { name: "github_list_repos", description: "List GitHub repositories accessible by the authenticated user", inputSchema: { type: "object", properties: { userId: { type: "string", description: "User ID (from session)" }, type: { type: "string", enum: ["all", "owner", "member"] } }, required: ["userId"] } },
-    { name: "github_create_branch", description: "Create a new branch on a GitHub repository", inputSchema: { type: "object", properties: { userId: { type: "string", description: "User ID" }, owner: { type: "string", description: "Repository owner" }, repo: { type: "string", description: "Repository name" }, branchName: { type: "string", description: "New branch name" }, sourceBranch: { type: "string", description: "Source branch (default: main)" } }, required: ["userId", "owner", "repo", "branchName"] } },
-    { name: "github_create_pr", description: "Create a pull request on a GitHub repository", inputSchema: { type: "object", properties: { userId: { type: "string", description: "User ID" }, owner: { type: "string", description: "Repository owner" }, repo: { type: "string", description: "Repository name" }, title: { type: "string", description: "PR title" }, head: { type: "string", description: "Branch containing changes" }, base: { type: "string", description: "Target branch" }, body: { type: "string", description: "PR description" } }, required: ["userId", "owner", "repo", "title", "head"] } },
-    { name: "github_auto_setup_webhook", description: "Automatically setup GitHub webhook for a Kanban project (requires user auth)", inputSchema: { type: "object", properties: { userId: { type: "string", description: "User ID" }, projectId: { type: "string", description: "Kanban project ID" }, owner: { type: "string", description: "Repository owner" }, repo: { type: "string", description: "Repository name" } }, required: ["userId", "projectId", "owner", "repo"] } }
+    {
+      name: "github_list_repos",
+      description: "List user repos",
+      inputSchema: {
+        type: "object",
+        properties: {
+          userId: { type: "string" },
+          type: { type: "string", enum: ["all", "owner", "member"] }
+        },
+        required: ["userId"]
+      }
+    },
+    {
+      name: "github_create_branch",
+      description: "Create branch",
+      inputSchema: {
+        type: "object",
+        properties: {
+          userId: { type: "string" },
+          owner: { type: "string" },
+          repo: { type: "string" },
+          branchName: { type: "string" },
+          sourceBranch: { type: "string" }
+        },
+        required: ["userId", "owner", "repo", "branchName"]
+      }
+    },
+    {
+      name: "github_create_pr",
+      description: "Create PR",
+      inputSchema: {
+        type: "object",
+        properties: {
+          userId: { type: "string" },
+          owner: { type: "string" },
+          repo: { type: "string" },
+          title: { type: "string" },
+          head: { type: "string" },
+          base: { type: "string" },
+          body: { type: "string" }
+        },
+        required: ["userId", "owner", "repo", "title", "head"]
+      }
+    },
+    // IDEAS
+    {
+      name: "list_ideas",
+      description: "List ideas (canvas notes). Filter by status: active, archived, all",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: { type: "string", enum: ["active", "archived", "all"] },
+          filter: { type: "string", enum: ["week"], description: "Filter by recent (week)" }
+        }
+      }
+    },
+    {
+      name: "get_idea",
+      description: "Get an idea with its tags",
+      inputSchema: {
+        type: "object",
+        properties: { ideaId: { type: "string" } },
+        required: ["ideaId"]
+      }
+    },
+    {
+      name: "create_idea",
+      description: "Create a new idea (canvas note)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          color: { type: "string" },
+          posX: { type: "number" },
+          posY: { type: "number" },
+          tagIds: { type: "array", items: { type: "string" } }
+        },
+        required: ["title"]
+      }
+    },
+    {
+      name: "update_idea",
+      description: "Update an idea",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ideaId: { type: "string" },
+          title: { type: "string" },
+          description: { type: "string" },
+          status: { type: "string", enum: ["active", "archived"] },
+          color: { type: "string" },
+          posX: { type: "number" },
+          posY: { type: "number" },
+          tagIds: { type: "array", items: { type: "string" } }
+        },
+        required: ["ideaId"]
+      }
+    },
+    {
+      name: "delete_idea",
+      description: "Delete an idea",
+      inputSchema: {
+        type: "object",
+        properties: { ideaId: { type: "string" } },
+        required: ["ideaId"]
+      }
+    },
+    {
+      name: "convert_idea_to_card",
+      description: "Convert an idea to a card in a specific board/column",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ideaId: { type: "string" },
+          boardId: { type: "string" },
+          columnId: { type: "string" }
+        },
+        required: ["ideaId", "boardId", "columnId"]
+      }
+    },
+    // TIME TRACKING
+    {
+      name: "get_time_tracking",
+      description: "Get time tracking sessions with project breakdown",
+      inputSchema: {
+        type: "object",
+        properties: {
+          startDate: { type: "string", description: "ISO date (default: 7 days ago)" },
+          endDate: { type: "string", description: "ISO date (default: now)" },
+          projectId: { type: "string" }
+        }
+      }
+    },
+    {
+      name: "log_activity",
+      description: "Log activity to create/update time session",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          cardId: { type: "string" },
+          activityType: { type: "string" }
+        }
+      }
+    },
+    {
+      name: "end_time_session",
+      description: "End the current active time tracking session",
+      inputSchema: { type: "object", properties: {} }
+    },
+    // DAILY SUMMARY
+    {
+      name: "get_daily_summary",
+      description: "Get daily report: working on, blocked, completed today, weekly stats",
+      inputSchema: { type: "object", properties: {} }
+    },
+    // RETROSPECTIVE
+    {
+      name: "get_retrospective",
+      description: "Get retrospective data: completed, created, stale, blocked cards + movements",
+      inputSchema: {
+        type: "object",
+        properties: {
+          days: { type: "number", description: "Period in days (default: 7)" }
+        }
+      }
+    },
+    // EXPORT
+    {
+      name: "export_board",
+      description: "Export a board as JSON (columns, cards, tags, comments)",
+      inputSchema: {
+        type: "object",
+        properties: { boardId: { type: "string" } },
+        required: ["boardId"]
+      }
+    },
+    {
+      name: "export_project",
+      description: "Export a project as JSON (boards, columns, cards)",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" } },
+        required: ["projectId"]
+      }
+    }
   ]
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -241,7 +1678,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = await kanbanApi.deleteFolder(args.folderId);
         break;
       case "move_project_to_folder":
-        result = await kanbanApi.moveProjectToFolder(args.projectId, args.folderId);
+        result = await kanbanApi.moveProjectToFolder(
+          args.projectId,
+          args.folderId
+        );
+        break;
+      case "reorder_folders":
+        result = await kanbanApi.reorderFolders(
+          args.folderId,
+          args.targetFolderId
+        );
         break;
       // PROJECTS
       case "list_projects":
@@ -251,7 +1697,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = await kanbanApi.createProject(args);
         break;
       case "get_project":
-        result = await kanbanApi.getProject(args.projectId);
+        result = await kanbanApi.getProject(args.projectId, args);
         break;
       case "update_project":
         result = await kanbanApi.updateProject(args.projectId, args);
@@ -259,9 +1705,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "delete_project":
         result = await kanbanApi.deleteProject(args.projectId);
         break;
+      case "reorder_projects":
+        result = await kanbanApi.reorderProjects(
+          args.projectId,
+          args.targetProjectId,
+          args.folderId
+        );
+        break;
       // BOARDS
       case "list_boards":
-        result = await kanbanApi.listBoards(args.projectId, args);
+        result = await kanbanApi.listBoards(args);
         break;
       case "create_board":
         result = await kanbanApi.createBoard(args);
@@ -285,7 +1738,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "delete_column":
         result = await kanbanApi.deleteColumn(args.columnId);
         break;
+      case "reorder_columns":
+        result = await kanbanApi.reorderColumns(args.columns);
+        break;
       // CARDS
+      case "get_card":
+        result = await kanbanApi.getCard(args.cardId);
+        break;
       case "create_card":
         result = await kanbanApi.createCard(args);
         break;
@@ -296,36 +1755,91 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = await kanbanApi.deleteCard(args.cardId);
         break;
       case "move_card":
-        result = await kanbanApi.moveCard(args.cardId, args.targetColumnId);
+        result = await kanbanApi.moveCard(args.cardId, args.targetColumnId, args.newOrder);
+        break;
+      case "archive_card":
+        result = await kanbanApi.archiveCard(args.cardId);
+        break;
+      case "unarchive_card":
+        result = await kanbanApi.unarchiveCard(args.cardId);
+        break;
+      case "list_archived_cards":
+        result = await kanbanApi.listArchivedCards(args.boardId);
         break;
       case "add_comment":
         result = await kanbanApi.addComment(args.cardId, args.content);
         break;
+      case "delete_comment":
+        result = await kanbanApi.deleteComment(args.commentId);
+        break;
       // CHECKLISTS
       case "create_checklist":
-        result = await kanbanApi.createChecklist({ cardId: args.cardId, title: args.title });
+        result = await kanbanApi.createChecklist({
+          cardId: args.cardId,
+          title: args.title
+        });
         break;
       case "update_checklist":
-        result = await kanbanApi.updateChecklist(args.checklistId, { title: args.title });
+        result = await kanbanApi.updateChecklist(args.checklistId, {
+          title: args.title
+        });
         break;
       case "delete_checklist":
         result = await kanbanApi.deleteChecklist(args.checklistId);
         break;
       case "create_checklist_item":
-        result = await kanbanApi.createChecklistItem({ checklistId: args.checklistId, content: args.content });
+        result = await kanbanApi.createChecklistItem({
+          checklistId: args.checklistId,
+          content: args.content
+        });
         break;
       case "update_checklist_item":
-        result = await kanbanApi.updateChecklistItem(args.itemId, { content: args.content, completed: args.completed });
+        result = await kanbanApi.updateChecklistItem(args.itemId, {
+          content: args.content,
+          completed: args.completed
+        });
         break;
       case "delete_checklist_item":
         result = await kanbanApi.deleteChecklistItem(args.itemId);
         break;
       case "get_branch_name":
-        result = await kanbanApi.getBranchName(args.cardId, args.type || "feature");
+        result = await kanbanApi.getBranchName(
+          args.cardId,
+          args.type || "feature"
+        );
         break;
       case "search_cards":
         result = await kanbanApi.searchCards(args);
         break;
+      // BULK OPERATIONS
+      case "bulk_create_cards":
+        result = await kanbanApi.bulkCreateCards(args);
+        break;
+      case "bulk_create_epic_with_cards":
+        result = await kanbanApi.bulkCreateEpicWithCards(args);
+        break;
+      case "bulk_create_epic_with_features":
+        result = await kanbanApi.bulkCreateEpicWithFeatures(args);
+        break;
+      case "bulk_move_cards":
+        result = await kanbanApi.bulkMoveCards(args);
+        break;
+      case "quick_add_cards":
+        result = await kanbanApi.quickAddCards(args);
+        break;
+      case "move_cards_by_column":
+        result = await kanbanApi.moveCardsByColumn(args);
+        break;
+      // AGGREGATED VIEWS
+      case "get_workspace":
+        result = await kanbanApi.getWorkspace(args.projectId);
+        break;
+      case "get_board_summary":
+        result = await kanbanApi.getBoardSummary(args.boardId);
+        break;
+      case "get_epic_summary":
+        result = await kanbanApi.getEpicSummary(args.epicId);
+        break;
       // TAGS
       case "list_tags":
         result = await kanbanApi.listTags();
@@ -364,22 +1878,75 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "remove_card_from_epic":
         result = await kanbanApi.removeCardFromEpic(args.epicId, args.cardId);
         break;
-      case "get_epic_timeline":
-        result = await kanbanApi.getEpicTimeline();
+      // FEATURES
+      case "list_features": {
+        const features = await kanbanApi.listFeatures(args.epicId);
+        const slugFilter = args.slug;
+        result = slugFilter ? (Array.isArray(features) ? features : []).filter((f) => f.slug === slugFilter.toUpperCase()) : features;
+        break;
+      }
+      case "get_feature": {
+        const fId = args.featureId || args.featureSlug;
+        if (!fId) throw new Error("Either featureId or featureSlug is required");
+        result = await kanbanApi.getFeature(fId);
+        break;
+      }
+      case "get_active_features":
+        result = await kanbanApi.getActiveFeatures();
         break;
+      case "create_feature":
+        result = await kanbanApi.createFeature(args);
+        break;
+      case "update_feature":
+        result = await kanbanApi.updateFeature(args.featureId, args);
+        break;
+      case "delete_feature":
+        result = await kanbanApi.deleteFeature(args.featureId);
+        break;
+      case "add_card_to_feature": {
+        let addFeatureId = args.featureId || args.featureSlug;
+        if (!addFeatureId) throw new Error("Either featureId or featureSlug is required");
+        if (args.featureSlug && !args.featureId) {
+          const resolved = await kanbanApi.getFeature(addFeatureId);
+          addFeatureId = resolved.id;
+        }
+        result = await kanbanApi.addCardToFeature(addFeatureId, args.cardId);
+        break;
+      }
+      case "remove_card_from_feature": {
+        let removeFeatureId = args.featureId || args.featureSlug;
+        if (!removeFeatureId) throw new Error("Either featureId or featureSlug is required");
+        if (args.featureSlug && !args.featureId) {
+          const resolved = await kanbanApi.getFeature(removeFeatureId);
+          removeFeatureId = resolved.id;
+        }
+        result = await kanbanApi.removeCardFromFeature(removeFeatureId, args.cardId);
+        break;
+      }
+      case "get_feature_cards": {
+        let cardsFeatureId = args.featureId || args.featureSlug;
+        if (!cardsFeatureId) throw new Error("Either featureId or featureSlug is required");
+        if (args.featureSlug && !args.featureId) {
+          const resolved = await kanbanApi.getFeature(cardsFeatureId);
+          cardsFeatureId = resolved.id;
+        }
+        result = await kanbanApi.getFeatureCards(cardsFeatureId);
+        break;
+      }
       // CARD LINKS
       case "link_cards":
-        result = await kanbanApi.linkCards(args.cardId1, args.cardId2, args.label);
+        result = await kanbanApi.linkCards(
+          args.cardId1,
+          args.cardId2,
+          args.label
+        );
         break;
       case "unlink_cards":
-        result = await kanbanApi.unlinkCards(args.cardId1, args.cardId2);
+        result = await kanbanApi.unlinkCards(args.linkId);
         break;
       case "get_linked_cards":
         result = await kanbanApi.getLinkedCards(args.cardId);
         break;
-      case "get_feature_cards":
-        result = await kanbanApi.getFeatureCards(args.cardId);
-        break;
       // GITHUB INTEGRATION
       case "setup_github_integration":
         result = await kanbanApi.setupGithubIntegration(args);
@@ -409,17 +1976,63 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "github_create_pr":
         result = await kanbanApi.githubCreatePr(args);
         break;
-      case "github_auto_setup_webhook":
-        result = await kanbanApi.githubAutoSetupWebhook(args);
+      // IDEAS
+      case "list_ideas":
+        result = await kanbanApi.listIdeas(args);
+        break;
+      case "get_idea":
+        result = await kanbanApi.getIdea(args.ideaId);
+        break;
+      case "create_idea":
+        result = await kanbanApi.createIdea(args);
+        break;
+      case "update_idea":
+        result = await kanbanApi.updateIdea(args.ideaId, args);
+        break;
+      case "delete_idea":
+        result = await kanbanApi.deleteIdea(args.ideaId);
+        break;
+      case "convert_idea_to_card":
+        result = await kanbanApi.convertIdeaToCard(args.ideaId, {
+          boardId: args.boardId,
+          columnId: args.columnId
+        });
+        break;
+      // TIME TRACKING
+      case "get_time_tracking":
+        result = await kanbanApi.getTimeTracking(args);
+        break;
+      case "log_activity":
+        result = await kanbanApi.logActivity(args);
+        break;
+      case "end_time_session":
+        result = await kanbanApi.endTimeSession();
+        break;
+      // DAILY SUMMARY
+      case "get_daily_summary":
+        result = await kanbanApi.getDailySummary();
+        break;
+      // RETROSPECTIVE
+      case "get_retrospective":
+        result = await kanbanApi.getRetrospective(args.days);
+        break;
+      // EXPORT
+      case "export_board":
+        result = await kanbanApi.exportBoard(args.boardId);
+        break;
+      case "export_project":
+        result = await kanbanApi.exportProject(args.projectId);
         break;
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
     return {
-      content: [{
-        type: "text",
-        text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
-      }]
+      content: [
+        {
+          type: "text",
+          text: typeof result === "string" ? result : JSON.stringify(result)
+        }
+      ]
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";