taskin 4.1.4 → 4.3.0

package/dist/index.js

@@ -278,8 +278,8 @@ ${body}` : subject;
         }
         const lines = output.split("\n").filter((l) => l.trim());
         for (const line of lines) {
-          const [added, removed, path12] = line.split("	");
-          if (added === void 0 || removed === void 0 || path12 === void 0) continue;
+          const [added, removed, path16] = line.split("	");
+          if (added === void 0 || removed === void 0 || path16 === void 0) continue;
           if (added === "-" || removed === "-") {
             continue;
           }
@@ -288,7 +288,7 @@ ${body}` : subject;
           totalLinesAdded += linesAdded;
           totalLinesRemoved += linesRemoved;
           files.push({
-            path: path12,
+            path: path16,
             linesAdded,
             linesRemoved,
             changeType: "modified"
@@ -314,15 +314,15 @@ ${body}` : subject;
         if (!output) {
           return null;
         }
-        const [added, removed, path12] = output.split("	");
-        if (added === void 0 || removed === void 0 || path12 === void 0) {
+        const [added, removed, path16] = output.split("	");
+        if (added === void 0 || removed === void 0 || path16 === void 0) {
           return null;
         }
         if (added === "-" || removed === "-") {
           return null;
         }
         return {
-          path: path12,
+          path: path16,
           linesAdded: parseInt(added, 10),
           linesRemoved: parseInt(removed, 10),
           changeType: "modified"
@@ -493,8 +493,8 @@ var init_git_service = __esm({
             }).trim();
             if (files) {
               taskFilePath = files.split("\n")[0] ?? null;
-              const { readFileSync: readFileSync4 } = await import("fs");
-              taskFileContent = readFileSync4(`${this.cwd}/${taskFilePath}`, "utf-8");
+              const { readFileSync: readFileSync7 } = await import("fs");
+              taskFileContent = readFileSync7(`${this.cwd}/${taskFilePath}`, "utf-8");
             }
           } catch {
           }
@@ -514,8 +514,8 @@ var init_git_service = __esm({
             });
             let committed = false;
             if (taskFileContent && taskFilePath) {
-              const { writeFileSync: writeFileSync3 } = await import("fs");
-              writeFileSync3(`${this.cwd}/${taskFilePath}`, taskFileContent, "utf-8");
+              const { writeFileSync: writeFileSync4 } = await import("fs");
+              writeFileSync4(`${this.cwd}/${taskFilePath}`, taskFileContent, "utf-8");
               const message = buildTaskStatusCommitMessage({ taskId, status, ciSkipTag: this.ciSkipTag });
               committed = await this.addAndCommit(taskPattern, message);
             } else {
@@ -2737,6 +2737,610 @@ var init_src3 = __esm({
   }
 });
 
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/filter-tasks/filter-tasks.js
+function casaResponsavel2(task, procurado) {
+  const alvo = procurado.toLowerCase();
+  return contem2(task.assignee?.id, alvo) || contem2(task.assignee?.name, alvo);
+}
+function filterTasks2(tasks, criteria) {
+  return tasks.filter((task) => {
+    if (criteria.status !== void 0) {
+      if (task.status !== criteria.status)
+        return false;
+    } else if (criteria.open && !EM_ABERTO2.includes(task.status)) {
+      return false;
+    } else if (criteria.closed && !ENCERRADOS2.includes(task.status)) {
+      return false;
+    }
+    if (criteria.type !== void 0 && task.type !== criteria.type)
+      return false;
+    if (criteria.assignee !== void 0 && !casaResponsavel2(task, criteria.assignee))
+      return false;
+    if (criteria.text !== void 0) {
+      const procurado = criteria.text.toLowerCase();
+      const casa = task.id.toLowerCase().includes(procurado) || contem2(task.title, procurado) || contem2(task.status, procurado) || casaResponsavel2(task, procurado);
+      if (!casa)
+        return false;
+    }
+    return true;
+  });
+}
+function summarizeTask2(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    type: task.type,
+    ...task.assignee && { assignee: { id: task.assignee.id, name: task.assignee.name } },
+    ...task.order !== void 0 && { priority: task.order },
+    ...task.groupId && { groupId: task.groupId },
+    ...task.groupName && { groupName: task.groupName },
+    ...task.difficulty !== void 0 && { difficulty: task.difficulty }
+  };
+}
+var EM_ABERTO2, ENCERRADOS2, contem2;
+var init_filter_tasks = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/filter-tasks/filter-tasks.js"() {
+    "use strict";
+    init_esm_shims();
+    EM_ABERTO2 = ["pending", "in-progress", "paused", "in-review", "blocked"];
+    ENCERRADOS2 = ["done", "canceled"];
+    contem2 = (valor, procurado) => valor?.toLowerCase().includes(procurado) ?? false;
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/filter-tasks/index.js
+var init_filter_tasks2 = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/filter-tasks/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_filter_tasks();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/metrics.types.js
+var init_metrics_types = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/metrics.types.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/task-manager.js
+var init_task_manager = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/task-manager.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/task-manager.types.js
+var init_task_manager_types = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/task-manager.types.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/user-registry.types.js
+var init_user_registry_types = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/user-registry.types.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/index.js
+var init_dist = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_filter_tasks2();
+    init_metrics_types();
+    init_task_manager();
+    init_task_manager_types();
+    init_user_registry_types();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { TaskIdSchema as TaskIdSchema4 } from "@opentask/taskin-types";
+function readTaskId(raw) {
+  if (typeof raw !== "string")
+    return void 0;
+  const parsed = TaskIdSchema4.safeParse(raw);
+  return parsed.success ? parsed.data : void 0;
+}
+function invalidTaskId(raw) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Invalid task id: ${JSON.stringify(raw)}. Expected the numeric id of a task, e.g. "020".`
+      }
+    ],
+    isError: true
+  };
+}
+async function createTaskMCPServer(taskManager, options) {
+  const server = new TaskMCPServer({
+    taskManager,
+    ...options
+  });
+  await server.connect({ transport: "stdio" });
+  return server;
+}
+var TaskMCPServer;
+var init_task_server_mcp = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist();
+    TaskMCPServer = class _TaskMCPServer {
+      server;
+      taskManager;
+      config;
+      constructor(config) {
+        this.taskManager = config.taskManager;
+        this.config = {
+          name: "taskin-mcp-server",
+          version: "1.0.0",
+          debug: false,
+          ...config,
+          taskManager: config.taskManager
+        };
+        this.server = new Server({
+          name: this.config.name,
+          version: this.config.version
+        }, {
+          capabilities: {
+            tools: {},
+            prompts: {},
+            resources: {}
+          }
+        });
+        this.setupHandlers();
+      }
+      /**
+       * Setup MCP request handlers
+       */
+      setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+          const { tools } = this.listTools();
+          return { tools };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+          const result = await this.callTool({
+            name: request.params.name,
+            arguments: request.params.arguments
+          });
+          return {
+            content: result.content,
+            isError: result.isError
+          };
+        });
+        this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
+          const { prompts } = this.listPrompts();
+          return { prompts };
+        });
+        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+          const result = await this.getPrompt({
+            name: request.params.name,
+            arguments: request.params.arguments
+          });
+          return {
+            messages: result.messages.map((msg) => ({
+              role: msg.role,
+              content: {
+                type: "text",
+                text: msg.content
+              }
+            }))
+          };
+        });
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+          const result = await this.listResources();
+          return { resources: result.resources };
+        });
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+          const result = await this.readResource({
+            uri: request.params.uri
+          });
+          return result;
+        });
+      }
+      /**
+       * Connect to MCP transport
+       *
+       * `MCPTransportType` tem um valor so, entao nao ha o que despachar. O ramo
+       * que existia aqui aceitava `'sse'` pelo tipo e recusava em tempo de
+       * execucao, ja com o provider inicializado.
+       */
+      async connect(_options) {
+        await this.server.connect(new StdioServerTransport());
+        this.log("MCP Server connected via stdio");
+      }
+      /**
+       * Get server information
+       */
+      getServerInfo() {
+        return {
+          name: this.config.name,
+          version: this.config.version,
+          protocolVersion: "2024-11-05",
+          capabilities: {
+            tools: {},
+            prompts: {},
+            resources: {}
+          }
+        };
+      }
+      /**
+       * List available tools
+       */
+      listTools() {
+        const tools = [
+          {
+            name: "list_tasks",
+            description: "List the tasks in the project. Returns a JSON array with what identifies each task \u2014 id, title, status, type, assignee \u2014 without the markdown body. Fetch a task body by id after choosing one.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                status: { type: "string", description: "Exact status (pending, in-progress, done, ...)" },
+                type: { type: "string", description: "Exact type (feat, fix, chore, ...)" },
+                assignee: { type: "string", description: "Assignee id or name, whole or in part" },
+                open: { type: "boolean", description: "Only tasks still open" },
+                closed: { type: "boolean", description: "Only tasks already closed" },
+                text: { type: "string", description: "Free text over id, title, status and assignee" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "start_task",
+            description: "Start working on a task by changing its status to in-progress",
+            inputSchema: {
+              type: "object",
+              properties: {
+                taskId: {
+                  type: "string",
+                  description: "The unique identifier of the task (UUID)"
+                }
+              },
+              required: ["taskId"]
+            }
+          },
+          {
+            name: "finish_task",
+            description: "Mark a task as completed by changing its status to done",
+            inputSchema: {
+              type: "object",
+              properties: {
+                taskId: {
+                  type: "string",
+                  description: "The unique identifier of the task (UUID)"
+                }
+              },
+              required: ["taskId"]
+            }
+          }
+        ];
+        return { tools };
+      }
+      /**
+       * Call a tool
+       */
+      async callTool(params) {
+        try {
+          this.log(`Calling tool: ${params.name}`, params.arguments);
+          switch (params.name) {
+            case "list_tasks":
+              return await this.handleListTasks(params.arguments ?? {});
+            case "start_task": {
+              const taskId = readTaskId(params.arguments?.taskId);
+              return taskId ? await this.handleStartTask(taskId) : invalidTaskId(params.arguments?.taskId);
+            }
+            case "finish_task": {
+              const taskId = readTaskId(params.arguments?.taskId);
+              return taskId ? await this.handleFinishTask(taskId) : invalidTaskId(params.arguments?.taskId);
+            }
+            default:
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Unknown tool: ${params.name}`
+                  }
+                ],
+                isError: true
+              };
+          }
+        } catch (error2) {
+          this.log("Tool call error:", error2);
+          return {
+            content: [
+              {
+                type: "text",
+                text: error2 instanceof Error ? error2.message : String(error2)
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      /**
+       * Handle start_task tool
+       */
+      async handleStartTask(taskId) {
+        const task = await this.taskManager.startTask(taskId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                message: `Task ${taskId} started successfully`,
+                task: {
+                  id: task.id,
+                  title: task.title,
+                  status: task.status,
+                  type: task.type
+                }
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      /**
+       * Handle finish_task tool
+       */
+      async handleFinishTask(taskId) {
+        const task = await this.taskManager.finishTask(taskId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                message: `Task ${taskId} finished successfully`,
+                task: {
+                  id: task.id,
+                  title: task.title,
+                  status: task.status,
+                  type: task.type
+                }
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      /**
+       * List available prompts
+       */
+      listPrompts() {
+        const prompts = [
+          {
+            name: "start-task-workflow",
+            description: "Guide the user through starting work on a task with git branch creation",
+            arguments: [
+              {
+                name: "taskId",
+                description: "The task ID to start",
+                required: true
+              }
+            ]
+          },
+          {
+            name: "finish-task-workflow",
+            description: "Guide the user through completing a task with commit and PR creation",
+            arguments: [
+              {
+                name: "taskId",
+                description: "The task ID to finish",
+                required: true
+              }
+            ]
+          },
+          {
+            name: "task-summary",
+            description: "Generate a summary of a task for documentation or reports",
+            arguments: [
+              {
+                name: "taskId",
+                description: "The task ID to summarize",
+                required: true
+              }
+            ]
+          }
+        ];
+        return { prompts };
+      }
+      /**
+       * Get a prompt
+       */
+      async getPrompt(params) {
+        this.log(`Getting prompt: ${params.name}`, params.arguments);
+        switch (params.name) {
+          case "start-task-workflow":
+            return {
+              description: "Workflow for starting a task",
+              messages: [
+                {
+                  role: "user",
+                  content: {
+                    type: "text",
+                    text: `I want to start working on task ${params.arguments?.taskId}. Can you help me set everything up?`
+                  }
+                },
+                {
+                  role: "assistant",
+                  content: {
+                    type: "text",
+                    text: `I'll help you start working on task ${params.arguments?.taskId}. Here's what I'll do:
+
+1. Mark the task as "in-progress"
+2. Create a git branch based on the task type and ID
+3. Ensure your working directory is clean
+4. Switch to the new branch
+
+Let me start by marking the task as in-progress using the start_task tool.`
+                  }
+                }
+              ]
+            };
+          case "finish-task-workflow":
+            return {
+              description: "Workflow for finishing a task",
+              messages: [
+                {
+                  role: "user",
+                  content: {
+                    type: "text",
+                    text: `I've completed task ${params.arguments?.taskId}. What should I do next?`
+                  }
+                },
+                {
+                  role: "assistant",
+                  content: {
+                    type: "text",
+                    text: `Great! Let me help you finish task ${params.arguments?.taskId}. Here's the workflow:
+
+1. Mark the task as "done"
+2. Ensure all changes are committed
+3. Push your branch to remote
+4. Create a pull request
+
+Let me start by marking the task as done using the finish_task tool.`
+                  }
+                }
+              ]
+            };
+          case "task-summary":
+            return {
+              description: "Generate task summary",
+              messages: [
+                {
+                  role: "user",
+                  content: {
+                    type: "text",
+                    text: `Can you provide a summary of task ${params.arguments?.taskId}?`
+                  }
+                },
+                {
+                  role: "assistant",
+                  content: {
+                    type: "text",
+                    text: `I'll generate a comprehensive summary of task ${params.arguments?.taskId} including its current status, description, and any relevant metadata.`
+                  }
+                }
+              ]
+            };
+          default:
+            throw new Error(`Unknown prompt: ${params.name}`);
+        }
+      }
+      /**
+       * Le e seleciona as tarefas, pela mesma seam que o CLI usa.
+       *
+       * `filterTasks` e `summarizeTask` vivem no pacote agnostico justamente para
+       * que a resposta aqui e a de `taskin list --json` nao possam divergir — ja
+       * houve duas filtragens discordando no repositorio.
+       */
+      async selecionarTarefas(criteria) {
+        const tasks = await this.taskManager.getAllTasks();
+        return filterTasks2(tasks, criteria).map(summarizeTask2);
+      }
+      /** Converte os argumentos crus da chamada MCP no criterio tipado. */
+      static criterioDe(args) {
+        return {
+          ...typeof args.status === "string" && { status: args.status },
+          ...typeof args.type === "string" && { type: args.type },
+          ...typeof args.assignee === "string" && { assignee: args.assignee },
+          ...args.open === true && { open: true },
+          ...args.closed === true && { closed: true },
+          ...typeof args.text === "string" && { text: args.text }
+        };
+      }
+      async handleListTasks(args) {
+        const tarefas = await this.selecionarTarefas(_TaskMCPServer.criterioDe(args));
+        return {
+          content: [{ type: "text", text: JSON.stringify(tarefas, null, 2) }],
+          isError: false
+        };
+      }
+      /**
+       * List available resources
+       */
+      async listResources() {
+        return {
+          resources: [
+            {
+              uri: "taskin://tasks",
+              name: "All Tasks",
+              description: "Access to all tasks in the system",
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+      /**
+       * Read a resource
+       */
+      async readResource(params) {
+        this.log(`Reading resource: ${params.uri}`);
+        const uri = params.uri;
+        if (uri === "taskin://tasks") {
+          const tarefas = await this.selecionarTarefas({});
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(tarefas, null, 2)
+              }
+            ]
+          };
+        }
+        throw new Error(`Unknown resource: ${uri}`);
+      }
+      /**
+       * Debug logging
+       */
+      log(...args) {
+        if (this.config.debug) {
+          console.error("[TaskMCPServer]", ...args);
+        }
+      }
+    };
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.types.js
+var init_task_server_mcp_types = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.types.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/@opentask/taskin-task-server-mcp/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  TaskMCPServer: () => TaskMCPServer,
+  createTaskMCPServer: () => createTaskMCPServer
+});
+var init_dist2 = __esm({
+  "node_modules/@opentask/taskin-task-server-mcp/dist/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_task_server_mcp();
+    init_task_server_mcp_types();
+  }
+});
+
 // src/index.ts
 init_esm_shims();
 import { Command } from "commander";
@@ -3456,6 +4060,51 @@ init_esm_shims();
 // ../task-manager/src/index.ts
 init_esm_shims();
 
+// ../task-manager/src/filter-tasks/index.ts
+init_esm_shims();
+
+// ../task-manager/src/filter-tasks/filter-tasks.ts
+init_esm_shims();
+var EM_ABERTO = ["pending", "in-progress", "paused", "in-review", "blocked"];
+var ENCERRADOS = ["done", "canceled"];
+var contem = (valor, procurado) => valor?.toLowerCase().includes(procurado) ?? false;
+function casaResponsavel(task, procurado) {
+  const alvo = procurado.toLowerCase();
+  return contem(task.assignee?.id, alvo) || contem(task.assignee?.name, alvo);
+}
+function filterTasks(tasks, criteria) {
+  return tasks.filter((task) => {
+    if (criteria.status !== void 0) {
+      if (task.status !== criteria.status) return false;
+    } else if (criteria.open && !EM_ABERTO.includes(task.status)) {
+      return false;
+    } else if (criteria.closed && !ENCERRADOS.includes(task.status)) {
+      return false;
+    }
+    if (criteria.type !== void 0 && task.type !== criteria.type) return false;
+    if (criteria.assignee !== void 0 && !casaResponsavel(task, criteria.assignee)) return false;
+    if (criteria.text !== void 0) {
+      const procurado = criteria.text.toLowerCase();
+      const casa = task.id.toLowerCase().includes(procurado) || contem(task.title, procurado) || contem(task.status, procurado) || casaResponsavel(task, procurado);
+      if (!casa) return false;
+    }
+    return true;
+  });
+}
+function summarizeTask(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    type: task.type,
+    ...task.assignee && { assignee: { id: task.assignee.id, name: task.assignee.name } },
+    ...task.order !== void 0 && { priority: task.order },
+    ...task.groupId && { groupId: task.groupId },
+    ...task.groupName && { groupName: task.groupName },
+    ...task.difficulty !== void 0 && { difficulty: task.difficulty }
+  };
+}
+
 // ../task-manager/src/metrics.types.ts
 init_esm_shims();
 
@@ -3502,6 +4151,16 @@ var TaskManager = class {
     await this.taskProvider.updateTask(updatedTask);
     return updatedTask;
   }
+  /**
+   * Every task the configured provider knows about.
+   *
+   * Pass-through on purpose: the manager owns the state transitions, not the
+   * storage. Having it here is what lets a consumer holding only the manager —
+   * the MCP server — answer "what work exists?".
+   */
+  async getAllTasks() {
+    return await this.taskProvider.getAllTasks();
+  }
   async finishTask(taskId) {
     const task = await this.taskProvider.findTask(taskId);
     if (!task) {
@@ -4313,7 +4972,7 @@ async function startDashboard(options) {
       }
     });
     await wsServer.start();
-    success(`\u2713 WebSocket server running on ws://${host}:${wsPort}`);
+    success(`WebSocket server running on ws://${host}:${wsPort}`);
     info(`Starting dashboard server on http://${host}:${port}...`);
     const isDev = __dirname2.includes("/src/");
     const dashboardDist = isDev ? path8.join(__dirname2, "..", "..", "dashboard-dist") : path8.join(__dirname2, "..", "dashboard-dist");
@@ -4364,7 +5023,7 @@ async function startDashboard(options) {
     if (actualPort !== port) {
       warning(`Port ${port} was in use. Dashboard started on port ${actualPort}.`);
     }
-    success(`\u2713 Dashboard available at http://${host}:${actualPort}`);
+    success(`Dashboard available at http://${host}:${actualPort}`);
     const filterParams = new URLSearchParams();
     if (options.open) {
       filterParams.set("filter", "open");
@@ -4396,7 +5055,7 @@ async function startDashboard(options) {
         httpServer.close(() => resolve());
       });
       await wsServer.stop();
-      success("\u2713 Servers stopped");
+      success("Servers stopped");
       process.exit(0);
     };
     process.on("SIGINT", cleanup);
@@ -4495,9 +5154,18 @@ init_src3();
 init_src();
 import { execSync as execSync5 } from "child_process";
 
-// src/lib/notification/notify-helper.ts
+// src/lib/ci-skip-tag/index.ts
 init_esm_shims();
-import { execSync as execSync4 } from "child_process";
+
+// src/lib/ci-skip-tag/resolve-ci-skip-tag.ts
+init_esm_shims();
+function resolveCiSkipTag(configurada, skipCi) {
+  return skipCi === false ? "" : configurada;
+}
+
+// src/lib/notification/notify-helper.ts
+init_esm_shims();
+import { execSync as execSync4 } from "child_process";
 
 // src/lib/debug.ts
 init_esm_shims();
@@ -4891,6 +5559,10 @@ var finishCommand = defineCommand({
     {
       flags: "--dry-run",
       description: "Show what would be executed without running"
+    },
+    {
+      flags: "--no-skip-ci",
+      description: "Write the status commit without the CI-skip tag"
     }
   ],
   handler: async (taskId, options) => {
@@ -4916,11 +5588,12 @@ async function finishTask(taskId, options, gitService) {
   info(`Current status: ${task.status}`);
   const configManager = new ConfigManager(monorepoRoot);
   const behavior = configManager.getAutomationBehavior();
+  const ciSkipTag = resolveCiSkipTag(behavior.ciSkipTag, options.skipCi);
   const autoSyncActive = behavior.autoSync && !!behavior.defaultBranch;
   const statusCommitMessage = buildTaskStatusCommitMessage({
     taskId: normalizedId,
     status: "done",
-    ciSkipTag: behavior.ciSkipTag
+    ciSkipTag
   });
   if (options.dryRun) {
     console.log();
@@ -4943,7 +5616,7 @@ async function finishTask(taskId, options, gitService) {
     );
     console.log(colors.secondary(`  - Push: git push`));
     console.log();
-    info("\u2713 Dry run complete");
+    info("Dry run complete");
     return;
   }
   if (task.status === "done") {
@@ -4953,7 +5626,7 @@ async function finishTask(taskId, options, gitService) {
   if (behavior.autoSync && !behavior.defaultBranch) {
     warning("autoSync is enabled but no defaultBranch is configured. Nothing will be synced.");
   }
-  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag: behavior.ciSkipTag });
+  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag });
   if (!options.skipUpdate) {
     info("Marking task as done...");
     const updatedTask = await taskManager.finishTask(task.id);
@@ -4962,7 +5635,7 @@ async function finishTask(taskId, options, gitService) {
     if (behavior.autoCommitStatusChange) {
       const committed = await git.commitTaskStatusChangeOnBranch(normalizedId, "done", behavior.defaultBranch);
       if (committed) {
-        success("\u2713 Auto-committed status change");
+        success("Auto-committed status change");
       }
     }
     if (behavior.autoSync && behavior.originBranch && behavior.defaultBranch) {
@@ -4971,10 +5644,10 @@ async function finishTask(taskId, options, gitService) {
           taskId: normalizedId,
           defaultBranch: behavior.defaultBranch,
           originBranch: behavior.originBranch,
-          ciSkipTag: behavior.ciSkipTag
+          ciSkipTag
         });
         if (squashed) {
-          success(`\u2713 Squash commit pushed to ${behavior.originBranch}`);
+          success(`Squash commit pushed to ${behavior.originBranch}`);
         }
       } catch (squashError) {
         error(
@@ -4990,7 +5663,7 @@ async function finishTask(taskId, options, gitService) {
           cwd: process.cwd(),
           stdio: "ignore"
         });
-        success("\u2713 Auto-committed completed work");
+        success("Auto-committed completed work");
       } catch {
       }
     }
@@ -5212,7 +5885,7 @@ async function initializeTaskin(options) {
     await ensureProviderInstalled(selectedProvider);
   }
   const providerConfig = await setupProviderConfig(selectedProvider, cwd);
-  const ciSkipTag = await resolveCiSkipTag(options.ciSkipTag);
+  const ciSkipTag = await resolveCiSkipTag2(options.ciSkipTag);
   const config = {
     version: "1.0.3",
     automation: {
@@ -5227,7 +5900,7 @@ async function initializeTaskin(options) {
   };
   info("Creating configuration file...");
   writeFileSync2(configFile, JSON.stringify(config, null, 2), "utf-8");
-  success(`\u2713 Created ${colors.highlight(".taskin.json")}`);
+  success(`Created ${colors.highlight(".taskin.json")}`);
   if (process.env.CI !== "true" && selectedProvider.id === "fs") {
     await promptCreateFirstUser(cwd);
   }
@@ -5246,7 +5919,7 @@ async function initializeTaskin(options) {
   info("For more information, run: taskin --help");
   console.log();
 }
-async function resolveCiSkipTag(fromFlag) {
+async function resolveCiSkipTag2(fromFlag) {
   if (fromFlag !== void 0) {
     return normalizeCiSkipTag(fromFlag);
   }
@@ -5310,7 +5983,7 @@ async function setupProviderConfig(provider, cwd) {
   }));
   const answers = await inquirer2.prompt(questions);
   console.log();
-  success(`\u2713 ${provider.name} configuration saved`);
+  success(`${provider.name} configuration saved`);
   return answers;
 }
 async function setupFileSystemProvider(cwd) {
@@ -5352,7 +6025,7 @@ This is a sample task created during Taskin initialization.
 You can edit or delete this file. Use \`taskin list\` to see all tasks.
 `;
     writeFileSync2(sampleTaskFile, sampleTask, "utf-8");
-    success(`\u2713 Created sample task ${colors.highlight("task-001-setup-project.md")}`);
+    success(`Created sample task ${colors.highlight("task-001-setup-project.md")}`);
   }
   return {
     tasksDir: "TASKS",
@@ -5397,7 +6070,7 @@ async function promptCreateFirstUser(cwd) {
     email: answers.email
   };
   await userRegistry.saveUser(user);
-  success(`\u2713 User "${user.name}" (${user.email}) created successfully!`);
+  success(`User "${user.name}" (${user.email}) created successfully!`);
 }
 
 // src/commands/lint.ts
@@ -5518,6 +6191,10 @@ var listCommand = defineCommand({
     {
       flags: "--closed",
       description: "Show only closed tasks (done, canceled)"
+    },
+    {
+      flags: "--json",
+      description: "Print the tasks as JSON, for other tools to consume"
     }
   ],
   handler: async (filter, options) => {
@@ -5526,36 +6203,28 @@ var listCommand = defineCommand({
 });
 async function listTasks(filter, options) {
   requireTaskinProject();
-  printHeader("Task List", "\u{1F4CA}");
+  const comoJson = options.json === true;
+  if (!comoJson) {
+    printHeader("Task List", "\u{1F4CA}");
+  }
   const { provider: taskProvider } = await resolveTaskProvider();
   const tasks = await taskProvider.getAllTasks();
-  if (tasks.length === 0) {
+  if (tasks.length === 0 && !comoJson) {
     console.log(colors.warning("No tasks found in TASKS/ directory"));
     return;
   }
-  const openStatuses = ["pending", "in-progress", "paused", "in-review", "blocked"];
-  const closedStatuses = ["done", "canceled"];
-  let filteredTasks = tasks;
-  if (options.status) {
-    filteredTasks = filteredTasks.filter((t) => t.status === options.status);
-  } else if (options.open) {
-    filteredTasks = filteredTasks.filter((t) => t.status && openStatuses.includes(t.status));
-  } else if (options.closed) {
-    filteredTasks = filteredTasks.filter((t) => t.status && closedStatuses.includes(t.status));
-  }
-  if (options.type) {
-    filteredTasks = filteredTasks.filter((t) => t.type === options.type);
-  }
-  if (options.assignee) {
-    filteredTasks = filteredTasks.filter(
-      (t) => t.assignee?.name.toLowerCase().includes(options.assignee.toLowerCase()) || t.assignee?.id.toLowerCase().includes(options.assignee.toLowerCase())
-    );
-  }
-  if (filter) {
-    const lowerFilter = filter.toLowerCase();
-    filteredTasks = filteredTasks.filter(
-      (t) => t.id.includes(lowerFilter) || t.title.toLowerCase().includes(lowerFilter) || t.status.toLowerCase().includes(lowerFilter) || t.assignee?.name.toLowerCase().includes(lowerFilter) || t.assignee?.id.toLowerCase().includes(lowerFilter)
-    );
+  const criteria = {
+    ...options.status && { status: options.status },
+    ...options.type && { type: options.type },
+    ...options.assignee && { assignee: options.assignee },
+    ...options.open && { open: true },
+    ...options.closed && { closed: true },
+    ...filter && { text: filter }
+  };
+  const filteredTasks = filterTasks(tasks, criteria);
+  if (comoJson) {
+    console.log(JSON.stringify(filteredTasks.map(summarizeTask), null, 2));
+    return;
   }
   if (filteredTasks.length === 0) {
     console.log(colors.warning("No tasks match the filters"));
@@ -5623,448 +6292,324 @@ function getTypeColor(type) {
   }
 }
 
-// src/commands/mcp-server.ts
+// src/commands/mcp-install.ts
 init_esm_shims();
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import path14 from "path";
 
-// node_modules/@opentask/taskin-task-server-mcp/dist/index.js
+// src/lib/mcp-install/index.ts
 init_esm_shims();
 
-// node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.js
+// src/lib/mcp-install/merge-mcp-config.ts
 init_esm_shims();
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { TaskIdSchema as TaskIdSchema4 } from "@opentask/taskin-types";
-function readTaskId(raw) {
-  if (typeof raw !== "string")
-    return void 0;
-  const parsed = TaskIdSchema4.safeParse(raw);
-  return parsed.success ? parsed.data : void 0;
-}
-function invalidTaskId(raw) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Invalid task id: ${JSON.stringify(raw)}. Expected the numeric id of a task, e.g. "020".`
-      }
-    ],
-    isError: true
+var NOME_DO_SERVIDOR = "taskin";
+var ehObjeto = (valor) => typeof valor === "object" && valor !== null && !Array.isArray(valor);
+var mesmaEntrada = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function mergeMcpConfig(existente, entrada, options = {}) {
+  if (existente === void 0) {
+    return { outcome: "created", config: { mcpServers: { [NOME_DO_SERVIDOR]: entrada } } };
+  }
+  let lido;
+  try {
+    lido = JSON.parse(existente);
+  } catch {
+    return { outcome: "unreadable", reason: "o arquivo n\xE3o \xE9 JSON v\xE1lido" };
+  }
+  if (!ehObjeto(lido)) {
+    return { outcome: "unreadable", reason: "o conte\xFAdo n\xE3o \xE9 um objeto" };
+  }
+  const servidores = lido.mcpServers;
+  if (servidores !== void 0 && !ehObjeto(servidores)) {
+    return { outcome: "unreadable", reason: "`mcpServers` n\xE3o \xE9 um objeto" };
+  }
+  const atuais = ehObjeto(servidores) ? servidores : {};
+  const atual = atuais[NOME_DO_SERVIDOR];
+  if (atual !== void 0) {
+    if (mesmaEntrada(atual, entrada)) {
+      return { outcome: "unchanged" };
+    }
+    if (!options.overwrite) {
+      return { outcome: "conflict", current: atual };
+    }
+  }
+  const config = {
+    ...lido,
+    mcpServers: { ...atuais, [NOME_DO_SERVIDOR]: entrada }
   };
+  return atual === void 0 ? { outcome: "added", config } : { outcome: "replaced", config };
 }
-var TaskMCPServer = class {
-  server;
-  taskManager;
-  config;
-  constructor(config) {
-    this.taskManager = config.taskManager;
-    this.config = {
-      name: "taskin-mcp-server",
-      version: "1.0.0",
-      debug: false,
-      ...config,
-      taskManager: config.taskManager
-    };
-    this.server = new Server({
-      name: this.config.name,
-      version: this.config.version
-    }, {
-      capabilities: {
-        tools: {},
-        prompts: {},
-        resources: {}
-      }
-    });
-    this.setupHandlers();
+
+// src/lib/mcp-install/package-manager.ts
+init_esm_shims();
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import path11 from "path";
+var POR_LOCKFILE = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["package-lock.json", "npm"]
+];
+function declarado(raiz) {
+  try {
+    const { packageManager } = JSON.parse(readFileSync3(path11.join(raiz, "package.json"), "utf-8"));
+    if (typeof packageManager !== "string") return void 0;
+    const nome = packageManager.split("@")[0];
+    return POR_LOCKFILE.some(([, gerenciador]) => gerenciador === nome) ? nome : void 0;
+  } catch {
+    return void 0;
   }
-  /**
-   * Setup MCP request handlers
-   */
-  setupHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      const { tools } = this.listTools();
-      return { tools };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const result = await this.callTool({
-        name: request.params.name,
-        arguments: request.params.arguments
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: result.content
-          }
-        ],
-        isError: result.isError
-      };
-    });
-    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-      const { prompts } = this.listPrompts();
-      return { prompts };
-    });
-    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const result = await this.getPrompt({
-        name: request.params.name,
-        arguments: request.params.arguments
-      });
-      return {
-        messages: result.messages.map((msg) => ({
-          role: msg.role,
-          content: {
-            type: "text",
-            text: msg.content
-          }
-        }))
-      };
-    });
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      const result = await this.listResources();
-      return { resources: result.resources };
-    });
-    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      const result = await this.readResource({
-        uri: request.params.uri
-      });
-      return result;
-    });
+}
+function detectPackageManager2(raiz) {
+  const explicito = declarado(raiz);
+  if (explicito) return explicito;
+  for (const [lockfile, gerenciador] of POR_LOCKFILE) {
+    if (existsSync6(path11.join(raiz, lockfile))) return gerenciador;
   }
-  /**
-   * Connect to MCP transport
-   */
-  async connect(options) {
-    if (options.transport === "stdio") {
-      const transport = new StdioServerTransport();
-      await this.server.connect(transport);
-      this.log("MCP Server connected via stdio");
-    } else {
-      throw new Error(`Transport ${options.transport} not yet implemented`);
-    }
+  return "npm";
+}
+function mcpCommandFor(manager) {
+  switch (manager) {
+    case "pnpm":
+      return { command: "pnpm", args: ["exec", "taskin", "mcp-server"] };
+    case "yarn":
+      return { command: "yarn", args: ["taskin", "mcp-server"] };
+    case "bun":
+      return { command: "bunx", args: ["taskin", "mcp-server"] };
+    case "npm":
+      return { command: "npx", args: ["taskin", "mcp-server"] };
   }
-  /**
-   * Get server information
-   */
-  getServerInfo() {
-    return {
-      name: this.config.name,
-      version: this.config.version,
-      protocolVersion: "2024-11-05",
-      capabilities: {
-        tools: {},
-        prompts: {},
-        resources: {}
-      }
+}
+
+// src/lib/mcp-install/probe-server.ts
+init_esm_shims();
+import { spawn } from "child_process";
+var LIMITE_MS = 3e4;
+var requisicao = (id, method, params) => `${JSON.stringify({ jsonrpc: "2.0", id, method, ...params !== void 0 && { params } })}
+`;
+function probeMcpServer(entrada, cwd, esperadas = []) {
+  return new Promise((resolve) => {
+    const filho = spawn(entrada.command, [...entrada.args], {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let saida = "";
+    let erro = "";
+    let respondido = false;
+    const encerrar = (resultado) => {
+      if (respondido) return;
+      respondido = true;
+      clearTimeout(cronometro);
+      filho.kill();
+      resolve(resultado);
     };
-  }
-  /**
-   * List available tools
-   */
-  listTools() {
-    const tools = [
-      {
-        name: "start_task",
-        description: "Start working on a task by changing its status to in-progress",
-        inputSchema: {
-          type: "object",
-          properties: {
-            taskId: {
-              type: "string",
-              description: "The unique identifier of the task (UUID)"
-            }
-          },
-          required: ["taskId"]
-        }
-      },
-      {
-        name: "finish_task",
-        description: "Mark a task as completed by changing its status to done",
-        inputSchema: {
-          type: "object",
-          properties: {
-            taskId: {
-              type: "string",
-              description: "The unique identifier of the task (UUID)"
-            }
-          },
-          required: ["taskId"]
+    const cronometro = setTimeout(
+      () => encerrar({ ok: false, reason: `o servidor n\xE3o respondeu em ${LIMITE_MS / 1e3}s`, stderr: erro.trim() }),
+      LIMITE_MS
+    );
+    filho.on("error", (e) => encerrar({ ok: false, reason: e.message, stderr: erro.trim() }));
+    filho.stderr.on("data", (pedaco) => {
+      erro += pedaco.toString();
+    });
+    filho.stdout.on("data", (pedaco) => {
+      saida += pedaco.toString();
+      for (const linha2 of saida.split("\n")) {
+        if (!linha2.trim()) continue;
+        let mensagem;
+        try {
+          mensagem = JSON.parse(linha2);
+        } catch {
+          continue;
         }
-      }
-    ];
-    return { tools };
-  }
-  /**
-   * Call a tool
-   */
-  async callTool(params) {
-    try {
-      this.log(`Calling tool: ${params.name}`, params.arguments);
-      switch (params.name) {
-        case "start_task": {
-          const taskId = readTaskId(params.arguments?.taskId);
-          return taskId ? await this.handleStartTask(taskId) : invalidTaskId(params.arguments?.taskId);
+        if (mensagem.id !== 2) continue;
+        if (mensagem.error) {
+          encerrar({ ok: false, reason: `recusou tools/list: ${mensagem.error.message}`, stderr: erro.trim() });
+          return;
         }
-        case "finish_task": {
-          const taskId = readTaskId(params.arguments?.taskId);
-          return taskId ? await this.handleFinishTask(taskId) : invalidTaskId(params.arguments?.taskId);
+        const ferramentas = (mensagem.result?.tools ?? []).map((t) => t.name);
+        if (ferramentas.length === 0) {
+          encerrar({ ok: false, reason: "subiu, mas n\xE3o anuncia ferramenta nenhuma", stderr: erro.trim() });
+          return;
         }
-        default:
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Unknown tool: ${params.name}`
-              }
-            ],
-            isError: true
-          };
-      }
-    } catch (error2) {
-      this.log("Tool call error:", error2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: error2 instanceof Error ? error2.message : String(error2)
+        const faltando = esperadas.filter((nome) => !ferramentas.includes(nome));
+        encerrar(
+          faltando.length === 0 ? { ok: true, tools: ferramentas } : {
+            ok: false,
+            reason: `respondeu, mas sem ${faltando.join(", ")} \u2014 o comando provavelmente alcan\xE7a outra instala\xE7\xE3o do taskin (anunciou: ${ferramentas.join(", ")})`,
+            stderr: erro.trim()
           }
-        ],
-        isError: true
-      };
-    }
+        );
+        return;
+      }
+    });
+    filho.on(
+      "close",
+      (code) => encerrar({ ok: false, reason: `encerrou com c\xF3digo ${code} sem responder`, stderr: erro.trim() })
+    );
+    filho.stdin.write(
+      requisicao(1, "initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "taskin-install", version: "1" }
+      })
+    );
+    filho.stdin.write(requisicao(2, "tools/list"));
+  });
+}
+
+// src/lib/mcp-install/resolve-invocation.ts
+init_esm_shims();
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import path12 from "path";
+function viaScript(manager) {
+  if (manager === "npm") {
+    return { command: "npm", args: ["run", "taskin", "--", "mcp-server"] };
   }
-  /**
-   * Handle start_task tool
-   */
-  async handleStartTask(taskId) {
-    const task = await this.taskManager.startTask(taskId);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            success: true,
-            message: `Task ${taskId} started successfully`,
-            task: {
-              id: task.id,
-              title: task.title,
-              status: task.status,
-              type: task.type
-            }
-          }, null, 2)
-        }
-      ]
-    };
+  return { command: manager, args: ["taskin", "mcp-server"] };
+}
+function temScriptTaskin(raiz) {
+  try {
+    const { scripts } = JSON.parse(readFileSync4(path12.join(raiz, "package.json"), "utf-8"));
+    return typeof scripts?.taskin === "string";
+  } catch {
+    return false;
   }
-  /**
-   * Handle finish_task tool
-   */
-  async handleFinishTask(taskId) {
-    const task = await this.taskManager.finishTask(taskId);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            success: true,
-            message: `Task ${taskId} finished successfully`,
-            task: {
-              id: task.id,
-              title: task.title,
-              status: task.status,
-              type: task.type
-            }
-          }, null, 2)
-        }
-      ]
-    };
+}
+function resolveInvocation(raiz, manager) {
+  if (existsSync7(path12.join(raiz, "node_modules", ".bin", "taskin"))) {
+    return mcpCommandFor(manager);
   }
-  /**
-   * List available prompts
-   */
-  listPrompts() {
-    const prompts = [
-      {
-        name: "start-task-workflow",
-        description: "Guide the user through starting work on a task with git branch creation",
-        arguments: [
-          {
-            name: "taskId",
-            description: "The task ID to start",
-            required: true
-          }
-        ]
-      },
-      {
-        name: "finish-task-workflow",
-        description: "Guide the user through completing a task with commit and PR creation",
-        arguments: [
-          {
-            name: "taskId",
-            description: "The task ID to finish",
-            required: true
-          }
-        ]
-      },
-      {
-        name: "task-summary",
-        description: "Generate a summary of a task for documentation or reports",
-        arguments: [
-          {
-            name: "taskId",
-            description: "The task ID to summarize",
-            required: true
-          }
-        ]
-      }
-    ];
-    return { prompts };
+  if (temScriptTaskin(raiz)) {
+    return viaScript(manager);
   }
-  /**
-   * Get a prompt
-   */
-  async getPrompt(params) {
-    this.log(`Getting prompt: ${params.name}`, params.arguments);
-    switch (params.name) {
-      case "start-task-workflow":
-        return {
-          description: "Workflow for starting a task",
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `I want to start working on task ${params.arguments?.taskId}. Can you help me set everything up?`
-              }
-            },
-            {
-              role: "assistant",
-              content: {
-                type: "text",
-                text: `I'll help you start working on task ${params.arguments?.taskId}. Here's what I'll do:
-
-1. Mark the task as "in-progress"
-2. Create a git branch based on the task type and ID
-3. Ensure your working directory is clean
-4. Switch to the new branch
+  return mcpCommandFor(manager);
+}
 
-Let me start by marking the task as in-progress using the start_task tool.`
-              }
-            }
-          ]
-        };
-      case "finish-task-workflow":
-        return {
-          description: "Workflow for finishing a task",
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `I've completed task ${params.arguments?.taskId}. What should I do next?`
-              }
-            },
-            {
-              role: "assistant",
-              content: {
-                type: "text",
-                text: `Great! Let me help you finish task ${params.arguments?.taskId}. Here's the workflow:
+// src/lib/project-root/index.ts
+init_esm_shims();
 
-1. Mark the task as "done"
-2. Ensure all changes are committed
-3. Push your branch to remote
-4. Create a pull request
+// src/lib/project-root/project-root.ts
+init_esm_shims();
+import { statSync } from "fs";
+import path13 from "path";
+var MARCADOR = ".taskin.json";
+function temMarcador(diretorio) {
+  try {
+    return statSync(path13.join(diretorio, MARCADOR)).isFile();
+  } catch {
+    return false;
+  }
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let atual = path13.resolve(startDir);
+  while (true) {
+    if (temMarcador(atual)) return atual;
+    const acima = path13.dirname(atual);
+    if (acima === atual) return void 0;
+    atual = acima;
+  }
+}
 
-Let me start by marking the task as done using the finish_task tool.`
-              }
-            }
-          ]
-        };
-      case "task-summary":
-        return {
-          description: "Generate task summary",
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `Can you provide a summary of task ${params.arguments?.taskId}?`
-              }
-            },
-            {
-              role: "assistant",
-              content: {
-                type: "text",
-                text: `I'll generate a comprehensive summary of task ${params.arguments?.taskId} including its current status, description, and any relevant metadata.`
-              }
-            }
-          ]
-        };
-      default:
-        throw new Error(`Unknown prompt: ${params.name}`);
+// src/commands/mcp-install.ts
+var ARQUIVO = ".mcp.json";
+function lerSeExistir(caminho) {
+  try {
+    return readFileSync5(caminho, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+var mcpInstallCommand = defineCommand({
+  name: "mcp-install",
+  description: "\u{1F50C} Register the Taskin MCP server in this project's .mcp.json",
+  options: [
+    {
+      flags: "-f, --force",
+      description: "Replace an existing taskin entry that differs"
+    },
+    {
+      flags: "--no-probe",
+      description: "Skip starting the server to verify the entry works"
     }
+  ],
+  handler: async (options) => {
+    await instalar(options);
   }
-  /**
-   * List available resources
-   */
-  async listResources() {
-    return {
-      resources: [
-        {
-          uri: "taskin://tasks",
-          name: "All Tasks",
-          description: "Access to all tasks in the system",
-          mimeType: "application/json"
-        }
-      ]
-    };
+});
+async function instalar(options) {
+  const raiz = findProjectRoot();
+  if (!raiz) {
+    error('No .taskin.json found here or in any parent directory. Run "taskin init" first.');
+    process.exit(1);
   }
-  /**
-   * Read a resource
-   */
-  async readResource(params) {
-    this.log(`Reading resource: ${params.uri}`);
-    const uri = params.uri;
-    if (uri === "taskin://tasks") {
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify({
-              message: "Task list would be here",
-              note: "Requires ITaskProvider integration"
-            })
-          }
-        ]
-      };
-    }
-    throw new Error(`Unknown resource: ${uri}`);
+  const caminho = path14.join(raiz, ARQUIVO);
+  const manager = detectPackageManager2(raiz);
+  const entrada = resolveInvocation(raiz, manager);
+  info(`Project root: ${raiz}`);
+  info(`Package manager: ${manager} \u2014 the entry will run \`${[entrada.command, ...entrada.args].join(" ")}\``);
+  const resultado = mergeMcpConfig(lerSeExistir(caminho), entrada, { overwrite: options.force === true });
+  switch (resultado.outcome) {
+    case "unreadable":
+      error(`${ARQUIVO} exists but ${resultado.reason}. Nothing was written \u2014 fix or remove it first.`);
+      process.exit(1);
+      return;
+    case "conflict":
+      warning(`${ARQUIVO} already has a "${NOME_DO_SERVIDOR}" entry that differs:`);
+      console.log(`  current: ${JSON.stringify(resultado.current)}`);
+      console.log(`  new:     ${JSON.stringify(entrada)}`);
+      info("Run again with --force to replace it.");
+      process.exit(1);
+      return;
+    case "unchanged":
+      success(`${ARQUIVO} already registers the Taskin MCP server. Nothing to do.`);
+      break;
+    default:
+      writeFileSync3(caminho, `${JSON.stringify(resultado.config, null, 2)}
+`, "utf-8");
+      success(
+        resultado.outcome === "created" ? `Created ${ARQUIVO}` : `${resultado.outcome === "added" ? "Added" : "Replaced"} the "${NOME_DO_SERVIDOR}" entry in ${ARQUIVO}`
+      );
   }
-  /**
-   * Debug logging
-   */
-  log(...args) {
-    if (this.config.debug) {
-      console.error("[TaskMCPServer]", ...args);
+  if (options.probe === false) {
+    info("Skipped the check. Run without --no-probe to verify the server actually starts.");
+    return;
+  }
+  info("Starting the server to check the entry actually works...");
+  const { TaskMCPServer: TaskMCPServer2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  const esperadas = new TaskMCPServer2({ taskManager: {} }).listTools().tools.map((t) => t.name);
+  const sonda = await probeMcpServer(entrada, raiz, esperadas);
+  if (!sonda.ok) {
+    error(`The entry was written, but the server did not answer: ${sonda.reason}`);
+    if (sonda.stderr) {
+      console.log(sonda.stderr);
     }
+    process.exit(1);
+    return;
   }
-};
-
-// node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.types.js
-init_esm_shims();
+  success(`The server answered with ${sonda.tools.length} tool(s): ${sonda.tools.join(", ")}`);
+}
 
 // src/commands/mcp-server.ts
+init_esm_shims();
+init_dist2();
 import chalk6 from "chalk";
+var linha = (texto = "") => process.stderr.write(`${texto}
+`);
+var aviso = (mensagem) => linha(colors.info(`\u2139 ${mensagem}`));
+var feito = (mensagem) => linha(colors.success(`\u2713 ${mensagem}`));
+var falha = (mensagem) => linha(colors.error(`\u2717 ${mensagem}`));
+function cabecalho(titulo, icone) {
+  linha();
+  linha(colors.highlight("=".repeat(60)));
+  linha(colors.highlight(`${icone}  ${titulo}`));
+  linha(colors.highlight("=".repeat(60)));
+  linha();
+}
 var mcpServerCommand = defineCommand({
   name: "mcp-server",
   description: "\u{1F916} Start Model Context Protocol server for LLM integration",
   alias: "mcp",
   options: [
-    {
-      flags: "-t, --transport <type>",
-      description: "Transport type (stdio or sse)",
-      defaultValue: "stdio"
-    },
     {
       flags: "-d, --debug",
       description: "Enable debug logging"
@@ -6076,45 +6621,40 @@ var mcpServerCommand = defineCommand({
 });
 async function startMCPServer(options) {
   requireTaskinProject();
-  const transport = options.transport || "stdio";
   const debug = options.debug || false;
-  printHeader("Starting MCP Server", "\u{1F916}");
+  cabecalho("Starting MCP Server", "\u{1F916}");
   try {
-    info("Initializing task manager...");
+    aviso("Initializing task manager...");
     const { provider } = await resolveTaskProvider();
     const manager = new TaskManager(provider);
-    info(`Creating MCP server with ${transport} transport...`);
     const mcpServer = new TaskMCPServer({
       taskManager: manager,
       name: "taskin-mcp-server",
       version: "1.0.0",
       debug
     });
-    info("Starting MCP server...");
-    await mcpServer.connect({ transport });
-    success("\u2713 MCP server started successfully");
-    info("");
-    info(chalk6.bold("Server Information:"));
-    info(`  \u2022 Transport: ${chalk6.cyan(transport)}`);
-    info(`  \u2022 Debug: ${chalk6.cyan(debug ? "enabled" : "disabled")}`);
-    info("");
-    info(chalk6.bold("Available Tools:"));
-    info(`  \u2022 ${chalk6.green("start_task")} - Start working on a task`);
-    info(`  \u2022 ${chalk6.green("finish_task")} - Mark a task as finished`);
-    info("");
-    info(chalk6.bold("Available Prompts:"));
-    info(`  \u2022 ${chalk6.green("start-task-workflow")} - Guide for starting tasks`);
-    info(`  \u2022 ${chalk6.green("finish-task-workflow")} - Guide for finishing tasks`);
-    info(`  \u2022 ${chalk6.green("task-summary")} - Get task summary and insights`);
-    info("");
-    info(chalk6.bold("Available Resources:"));
-    info(`  \u2022 ${chalk6.green("taskin://tasks")} - Access all tasks`);
-    info("");
-    info(`Press ${chalk6.bold("Ctrl+C")} to stop the server`);
-    info("");
-    const cleanup = async () => {
-      info("\nShutting down MCP server...");
-      success("\u2713 Server stopped");
+    aviso("Starting MCP server over stdio...");
+    await mcpServer.connect({ transport: "stdio" });
+    feito("MCP server started successfully");
+    linha();
+    aviso(`  ${chalk6.bold("Debug")}: ${chalk6.cyan(debug ? "enabled" : "disabled")}`);
+    linha();
+    aviso(chalk6.bold("Available Tools:"));
+    for (const ferramenta of mcpServer.listTools().tools) {
+      aviso(`  \u2022 ${chalk6.green(ferramenta.name)} - ${ferramenta.description}`);
+    }
+    linha();
+    aviso(chalk6.bold("Available Prompts:"));
+    for (const prompt of mcpServer.listPrompts().prompts) {
+      aviso(`  \u2022 ${chalk6.green(prompt.name)} - ${prompt.description}`);
+    }
+    linha();
+    aviso(`Press ${chalk6.bold("Ctrl+C")} to stop the server`);
+    linha();
+    const cleanup = () => {
+      linha();
+      aviso("Shutting down MCP server...");
+      feito("Server stopped");
       process.exit(0);
     };
     process.on("SIGINT", cleanup);
@@ -6122,9 +6662,9 @@ async function startMCPServer(options) {
     await new Promise(() => {
     });
   } catch (err) {
-    error("Failed to start MCP server");
+    falha("Failed to start MCP server");
     if (err instanceof Error) {
-      error(err.message);
+      falha(err.message);
       if (debug) {
         console.error(err.stack);
       }
@@ -6159,6 +6699,10 @@ var createCommand = defineCommand({
     {
       flags: "-u, --user <user>",
       description: "Assignee user"
+    },
+    {
+      flags: "--no-skip-ci",
+      description: "Write the status commit without the CI-skip tag"
     }
   ],
   handler: async (options) => {
@@ -6234,11 +6778,12 @@ async function createTask(options, gitService) {
   await userRegistry.ensureCurrentUser();
   const configManager = new ConfigManager(monorepoRoot);
   const behavior = configManager.getAutomationBehavior();
+  const ciSkipTag = resolveCiSkipTag(behavior.ciSkipTag, options.skipCi);
   const autoSyncActive = behavior.autoSync && !!behavior.defaultBranch;
   if (behavior.autoSync && !behavior.defaultBranch) {
     warning("autoSync is enabled but no defaultBranch is configured. Nothing will be synced.");
   }
-  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag: behavior.ciSkipTag });
+  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag });
   if (autoSyncActive) {
     try {
       await syncBeforeCreate(git, {
@@ -6271,7 +6816,7 @@ async function createTask(options, gitService) {
         taskId,
         title: options.title,
         defaultBranch: behavior.defaultBranch,
-        ciSkipTag: behavior.ciSkipTag
+        ciSkipTag
       });
     } catch (pushError) {
       error(
@@ -6287,7 +6832,7 @@ async function createTask(options, gitService) {
     console.log(colors.secondary(`\u{1F4C1} Path: ${createdPath}`));
   }
   if (autoSyncActive) {
-    success("\u2713 Task committed and pushed to remote");
+    success("Task committed and pushed to remote");
   }
   console.log();
   console.log(colors.info("Next steps:"));
@@ -6442,7 +6987,7 @@ async function pauseTask(taskId, options) {
     console.log(colors.secondary(`  - Add all changes: git add -A`));
     console.log(colors.secondary(`  - Commit: git commit -m "${commitMessage2}"`));
     console.log();
-    info("\u2713 Dry run complete");
+    info("Dry run complete");
     return;
   }
   if (task.status !== "in-progress") {
@@ -6476,7 +7021,7 @@ async function pauseTask(taskId, options) {
     }
     await taskManager.pauseTask(normalizedId);
     success("Task paused successfully!");
-    success("\u2713 Auto-committed work in progress");
+    success("Auto-committed work in progress");
     info("Status updated to paused");
     console.log();
     info("Next steps:");
@@ -6593,6 +7138,10 @@ var reviewCommand = defineCommand({
     {
       flags: "--no-sound",
       description: "Disable review sound"
+    },
+    {
+      flags: "--no-skip-ci",
+      description: "Write the status commit without the CI-skip tag"
     }
   ],
   handler: async (taskId, options) => {
@@ -6624,6 +7173,7 @@ async function reviewTask(taskId, options) {
   const hookSettings = configManager.getHookSettings();
   const reviewHooks = configManager.getCommandHooks("review");
   const behavior = configManager.getAutomationBehavior();
+  const ciSkipTag = resolveCiSkipTag(behavior.ciSkipTag, options.skipCi);
   const hookRunner = new HookRunner();
   const hookContext = {
     taskId: normalizedId,
@@ -6663,7 +7213,7 @@ async function reviewTask(taskId, options) {
       });
       console.log();
     }
-    info("\u2713 Dry run complete");
+    info("Dry run complete");
     return;
   }
   if (reviewHooks.pre && reviewHooks.pre.length > 0 && !options.skipMerge) {
@@ -6682,7 +7232,7 @@ async function reviewTask(taskId, options) {
     const failedPre = preResults.find((r) => !r.success);
     if (failedPre && !hookSettings.continueOnError) {
       console.log();
-      error("\u2717 Pre-review hooks failed!");
+      error("Pre-review hooks failed!");
       error("Fix the errors above and try again.");
       process.exit(1);
     }
@@ -6704,7 +7254,7 @@ async function reviewTask(taskId, options) {
     const failedCheck = duringResults.find((r) => !r.success);
     if (failedCheck && !hookSettings.continueOnError) {
       console.log();
-      error("\u2717 Review checks failed!");
+      error("Review checks failed!");
       error("Fix the errors above and try again.");
       console.log();
       info("Tip: Run individual checks to see full error details");
@@ -6714,18 +7264,15 @@ async function reviewTask(taskId, options) {
   }
   info("Marking task as ready for review...");
   const updatedTask = await taskManager.reviewTask(task.id);
-  success(`\u2713 Task ${updatedTask.id} status changed to: ${updatedTask.status}`);
+  success(`Task ${updatedTask.id} status changed to: ${updatedTask.status}`);
   if (behavior.autoCommitStatusChange) {
     try {
-      const message = appendCiSkipTag(
-        `docs(TASKS): task-${normalizedId} - mark as ready for review`,
-        behavior.ciSkipTag
-      );
+      const message = appendCiSkipTag(`docs(TASKS): task-${normalizedId} - mark as ready for review`, ciSkipTag);
       execSync9(`git add TASKS/task-${normalizedId}-*.md && git commit -m "${message}"`, {
         cwd: monorepoRoot,
         stdio: "ignore"
       });
-      success("\u2713 Auto-committed status change");
+      success("Auto-committed status change");
     } catch {
     }
   }
@@ -6746,7 +7293,7 @@ async function reviewTask(taskId, options) {
     console.log();
   }
   const totalDuration = [...reviewHooks.pre ?? [], ...reviewHooks.during ?? [], ...reviewHooks.post ?? []].length > 0 ? "with hooks" : "";
-  success(`\u2713 Task ready for review! ${totalDuration}`);
+  success(`Task ready for review! ${totalDuration}`);
   await sendTaskNotification(configManager, "task:review", normalizedId, task.title);
   if (options.sound !== false) {
     await playSound("review");
@@ -6793,13 +7340,17 @@ var startCommand = defineCommand({
     {
       flags: "--dry-run",
       description: "Show what would be executed without running"
+    },
+    {
+      flags: "--no-skip-ci",
+      description: "Write the status commit without the CI-skip tag"
     }
   ],
   handler: async (taskId, options) => {
     await startTask(taskId, options);
   }
 });
-async function startTask(taskId, _options, gitService) {
+async function startTask(taskId, options, gitService) {
   requireTaskinProject();
   printHeader(`Starting Task ${taskId}`, "\u{1F680}");
   const normalizedId = normalizeTaskId(taskId);
@@ -6819,12 +7370,13 @@ async function startTask(taskId, _options, gitService) {
   info(`Current status: ${task.status}`);
   const configManager = new ConfigManager(monorepoRoot);
   const behavior = configManager.getAutomationBehavior();
+  const ciSkipTag = resolveCiSkipTag(behavior.ciSkipTag, options.skipCi);
   const statusCommitMessage = buildTaskStatusCommitMessage({
     taskId: normalizedId,
     status: "in-progress",
-    ciSkipTag: behavior.ciSkipTag
+    ciSkipTag
   });
-  if (_options.dryRun) {
+  if (options.dryRun) {
     console.log();
     info("\u{1F50D} Dry run mode - showing what would be executed:");
     console.log();
@@ -6839,7 +7391,7 @@ async function startTask(taskId, _options, gitService) {
       )
     );
     console.log();
-    info("\u2713 Dry run complete");
+    info("Dry run complete");
     return;
   }
   if (task.status === "in-progress") {
@@ -6854,11 +7406,11 @@ async function startTask(taskId, _options, gitService) {
   const updatedTask = await taskManager.startTask(task.id);
   success(`Task ${updatedTask.id} started successfully!`);
   success(`Status changed to: ${updatedTask.status}`);
-  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag: behavior.ciSkipTag });
+  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag });
   if (behavior.autoCommitStatusChange) {
     const committed = await git.commitTaskStatusChangeOnBranch(normalizedId, "in-progress", behavior.defaultBranch);
     if (committed) {
-      success("\u2713 Auto-committed status change");
+      success("Auto-committed status change");
     }
   }
   console.log();
@@ -6880,7 +7432,7 @@ async function startTask(taskId, _options, gitService) {
   }
   console.log();
   await sendTaskNotification(configManager, "task:start", normalizedId, task.title);
-  if (_options.sound !== false) {
+  if (options.sound !== false) {
     playSound("start");
   }
 }
@@ -6890,7 +7442,7 @@ init_esm_shims();
 init_src3();
 init_src();
 import chalk7 from "chalk";
-import path11 from "path";
+import path15 from "path";
 var statsCommand = defineCommand({
   name: "stats",
   description: "\u{1F4CA} Show user/team metrics and statistics",
@@ -6922,7 +7474,7 @@ var statsCommand = defineCommand({
 });
 async function showStats(options) {
   requireTaskinProject();
-  const tasksDir = path11.join(process.cwd(), "TASKS");
+  const tasksDir = path15.join(process.cwd(), "TASKS");
   const { userRegistry } = await resolveTaskProvider();
   const gitAnalyzer = new GitAnalyzer(process.cwd());
   const metricsAdapter = new FileSystemMetricsAdapter(tasksDir, userRegistry, gitAnalyzer);
@@ -7077,102 +7629,73 @@ function getStatusEmoji(status) {
 
 // src/lib/help.ts
 init_esm_shims();
-function showCustomHelp() {
+var EXEMPLOS = {
+  init: ["taskin init", "taskin setup"],
+  list: ["taskin list", "taskin list pending", "taskin list --status in-progress", "taskin list --type feat"],
+  new: [
+    'taskin new -t feat -T "Add login" -d "Implement user authentication"',
+    'taskin new --type fix --title "Fix bug" --user "John"',
+    'taskin create -t docs -T "Update README"'
+  ],
+  start: ["taskin start 001", "taskin start task-001", "taskin start 001 --force"],
+  pause: ["taskin pause 001", 'taskin pause 001 -m "saving progress"'],
+  review: ["taskin review 001", "taskin review 001 --dry-run"],
+  finish: ["taskin finish 001", "taskin done task-001"],
+  stats: ["taskin stats", "taskin stats --team", "taskin stats --period month"],
+  config: ["taskin config", "taskin config --level assisted", "taskin config --show"],
+  export: ["taskin export", "taskin export --format json"],
+  lint: ["taskin lint", "taskin lint --fix", "taskin lint --fix --metadata-style=list"],
+  dashboard: ["taskin dashboard", "taskin dashboard --port 3000", "taskin dashboard --filter-open"],
+  "mcp-install": ["taskin mcp-install", "taskin mcp-install --force", "taskin mcp-install --no-probe"],
+  "mcp-server": ["taskin mcp-server", "taskin mcp"],
+  notify: ["taskin notify --event task:done --task 001"]
+};
+var ICONE_PADRAO = "\u2022";
+function separarIcone(descricao) {
+  const match = descricao.match(new RegExp("^(\\p{Extended_Pictographic}\\uFE0F?)\\s+(.*)$", "su"));
+  return match?.[1] && match[2] !== void 0 ? { icone: match[1], texto: match[2] } : { icone: ICONE_PADRAO, texto: descricao };
+}
+var OCULTOS = ["help"];
+function assinatura(cmd) {
+  const argumentos = cmd.usage().replace("[options]", "").trim();
+  const nome = colors.highlight(`taskin ${cmd.name()}`);
+  return argumentos ? nome + colors.normal(` ${argumentos}`) : nome;
+}
+function detalhes(cmd) {
+  const partes = [];
+  const aliases = cmd.aliases();
+  if (aliases.length > 0) {
+    partes.push(`Alias: ${aliases.join(", ")}`);
+  }
+  const flags = cmd.options.map((opcao) => opcao.flags.split(",")[0]?.trim()).filter(Boolean);
+  if (flags.length > 0) {
+    partes.push(`Options: ${flags.join(", ")}`);
+  }
+  return partes.length > 0 ? partes.join(" \xB7 ") : void 0;
+}
+function showCustomHelp(program2) {
   printHeader("Taskin - Task Management System", icons.rocket);
   console.log(colors.info("\u{1F4CB} AVAILABLE COMMANDS"));
   console.log(colors.highlight("\u2550".repeat(60)));
   console.log();
-  const commands = [
-    {
-      name: colors.highlight("taskin init"),
-      alias: colors.secondary("Alias: setup"),
-      description: "Initialize Taskin in your project",
-      examples: ["taskin init", "taskin setup"],
-      icon: "\u{1F3AF}"
-    },
-    {
-      name: colors.highlight("taskin list") + colors.normal(" [filter]"),
-      alias: colors.secondary("Alias: ls"),
-      description: "List all tasks in the project",
-      examples: ["taskin list", "taskin list pending", "taskin list --status in-progress", "taskin list --type feat"],
-      icon: "\u{1F4CA}"
-    },
-    {
-      name: colors.highlight("taskin new"),
-      alias: colors.secondary("Alias: create"),
-      description: "Create a new task",
-      examples: [
-        'taskin new -t feat -T "Add login" -d "Implement user authentication"',
-        'taskin new --type fix --title "Fix bug" --user "John"',
-        'taskin create -t docs -T "Update README"'
-      ],
-      icon: "\u{1F4DD}"
-    },
-    {
-      name: colors.highlight("taskin start") + colors.normal(" <task-id>"),
-      alias: colors.secondary("Alias: begin"),
-      description: "Start working on a task (suggests commits)",
-      examples: ["taskin start 001", "taskin start task-001", "taskin start 001 --force"],
-      icon: "\u{1F680}"
-    },
-    {
-      name: colors.highlight("taskin pause") + colors.normal(" <task-id>"),
-      alias: colors.secondary("Alias: stop"),
-      description: "Pause a task (auto-commits work in progress)",
-      examples: ["taskin pause 001", 'taskin pause 001 -m "saving progress"'],
-      icon: "\u23F8\uFE0F"
-    },
-    {
-      name: colors.highlight("taskin finish") + colors.normal(" <task-id>"),
-      alias: colors.secondary("Alias: done"),
-      description: "Finish a task (suggests commits)",
-      examples: ["taskin finish 001", "taskin done task-001"],
-      icon: "\u2705"
-    },
-    {
-      name: colors.highlight("taskin config") + colors.normal(" [options]"),
-      alias: colors.secondary("Options: --level <manual|assisted|autopilot>"),
-      description: "Configure automation level",
-      examples: ["taskin config", "taskin config --level assisted", "taskin config --level autopilot"],
-      icon: "\u2699\uFE0F"
-    },
-    {
-      name: colors.highlight("taskin lint") + colors.normal(" [options]"),
-      alias: colors.secondary("Options: -p, --path <directory>"),
-      description: "Validate task markdown files",
-      examples: ["taskin lint", "taskin lint --path ./TASKS", "taskin lint -p /path/to/tasks"],
-      icon: "\u{1F50D}"
-    },
-    {
-      name: colors.highlight("taskin dashboard") + colors.normal(" [options]"),
-      alias: colors.secondary("Options: --host, --port, --filter-open, --filter-closed"),
-      description: "Start the web dashboard",
-      examples: [
-        "taskin dashboard",
-        "taskin dashboard --port 3000",
-        "taskin dashboard --filter-open",
-        "taskin dashboard --filter-closed -o"
-      ],
-      icon: "\u{1F4CA}"
-    },
-    {
-      name: colors.highlight("taskin mcp-server"),
-      alias: colors.secondary("Alias: mcp"),
-      description: "Start MCP server for Claude Desktop integration",
-      examples: ["taskin mcp-server", "taskin mcp"],
-      icon: "\u{1F916}"
+  const comandos = program2.commands.filter((cmd) => !OCULTOS.includes(cmd.name()));
+  comandos.forEach((cmd, index) => {
+    const exemplos = EXEMPLOS[cmd.name()] ?? [];
+    const { icone, texto } = separarIcone(cmd.description());
+    console.log(colors.warning(`${icone} ${assinatura(cmd)}`));
+    const linhaDeDetalhes = detalhes(cmd);
+    if (linhaDeDetalhes) {
+      console.log(colors.normal(`   ${colors.secondary(linhaDeDetalhes)}`));
+    }
+    console.log(colors.info(`   ${texto}`));
+    if (exemplos.length > 0) {
+      console.log();
+      console.log(colors.normal(`   ${colors.info("\u{1F4DD} Examples:")}`));
+      for (const exemplo of exemplos) {
+        console.log(colors.secondary(`      ${exemplo}`));
+      }
     }
-  ];
-  commands.forEach((cmd, index) => {
-    console.log(colors.warning(`${cmd.icon} ${cmd.name}`));
-    console.log(colors.normal(`   ${cmd.alias}`));
-    console.log(colors.info(`   ${cmd.description}`));
-    console.log();
-    console.log(colors.normal(`   ${colors.info("\u{1F4DD} Examples:")}`));
-    cmd.examples.forEach((example) => {
-      console.log(colors.secondary(`      ${example}`));
-    });
-    if (index < commands.length - 1) {
+    if (index < comandos.length - 1) {
       console.log();
       console.log(colors.normal(`   ${colors.secondary("\u2500".repeat(50))}`));
       console.log();
@@ -7207,7 +7730,7 @@ function showCustomHelp() {
 
 // src/version.ts
 init_esm_shims();
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { dirname, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename3 = fileURLToPath3(import.meta.url);
@@ -7215,7 +7738,7 @@ var __dirname3 = dirname(__filename3);
 function getVersion() {
   try {
     const packageJsonPath = join4(__dirname3, "../package.json");
-    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
     return packageJson.version;
   } catch {
     return "0.0.0";
@@ -7574,7 +8097,7 @@ var program = new Command();
 program.name("taskin").description("\u{1F680} Task Management System").version(getVersion());
 program.helpOption("-h, --help", "Display help information");
 program.command("help").description("Show help information").action(() => {
-  showCustomHelp();
+  showCustomHelp(program);
 });
 initCommand(program);
 listCommand(program);
@@ -7588,18 +8111,19 @@ configCommand(program);
 registerExportCommand(program);
 lintCommand(program);
 dashboardCommand(program);
+mcpInstallCommand(program);
 mcpServerCommand(program);
 notifyCommand(program);
 program.on("option:help", () => {
-  showCustomHelp();
+  showCustomHelp(program);
   process.exit(0);
 });
 if (process.argv.length <= 2) {
-  showCustomHelp();
+  showCustomHelp(program);
   process.exit(0);
 }
 if (process.argv.length === 3 && (process.argv[2] === "--help" || process.argv[2] === "-h")) {
-  showCustomHelp();
+  showCustomHelp(program);
   process.exit(0);
 }
 program.parse();