taskin 4.2.0 → 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";
@@ -3463,7 +4067,7 @@ init_esm_shims();
 init_esm_shims();
 var EM_ABERTO = ["pending", "in-progress", "paused", "in-review", "blocked"];
 var ENCERRADOS = ["done", "canceled"];
-var contem = (valor, procurado) => valor !== void 0 && valor.toLowerCase().includes(procurado);
+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);
@@ -4550,6 +5154,15 @@ init_src3();
 init_src();
 import { execSync as execSync5 } from "child_process";
 
+// src/lib/ci-skip-tag/index.ts
+init_esm_shims();
+
+// 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";
@@ -4946,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) => {
@@ -4971,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();
@@ -5008,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);
@@ -5026,7 +5644,7 @@ async function finishTask(taskId, options, gitService) {
           taskId: normalizedId,
           defaultBranch: behavior.defaultBranch,
           originBranch: behavior.originBranch,
-          ciSkipTag: behavior.ciSkipTag
+          ciSkipTag
         });
         if (squashed) {
           success(`Squash commit pushed to ${behavior.originBranch}`);
@@ -5267,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: {
@@ -5301,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);
   }
@@ -5674,554 +6292,324 @@ function getTypeColor(type) {
   }
 }
 
-// src/commands/mcp-server.ts
-init_esm_shims();
-
-// node_modules/@opentask/taskin-task-server-mcp/dist/index.js
-init_esm_shims();
-
-// node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.js
-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";
-
-// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/index.js
+// 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/node_modules/@opentask/taskin-task-manager/dist/filter-tasks/index.js
+// src/lib/mcp-install/index.ts
 init_esm_shims();
 
-// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/filter-tasks/filter-tasks.js
+// src/lib/mcp-install/merge-mcp-config.ts
 init_esm_shims();
-var EM_ABERTO2 = ["pending", "in-progress", "paused", "in-review", "blocked"];
-var ENCERRADOS2 = ["done", "canceled"];
-var contem2 = (valor, procurado) => valor !== void 0 && valor.toLowerCase().includes(procurado);
-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;
+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 (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;
+    if (!options.overwrite) {
+      return { outcome: "conflict", current: atual };
     }
-    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 }
+  }
+  const config = {
+    ...lido,
+    mcpServers: { ...atuais, [NOME_DO_SERVIDOR]: entrada }
   };
+  return atual === void 0 ? { outcome: "added", config } : { outcome: "replaced", config };
 }
 
-// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/metrics.types.js
-init_esm_shims();
-
-// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/task-manager.js
-init_esm_shims();
-
-// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/task-manager.types.js
-init_esm_shims();
-
-// node_modules/@opentask/taskin-task-server-mcp/node_modules/@opentask/taskin-task-manager/dist/user-registry.types.js
+// src/lib/mcp-install/package-manager.ts
 init_esm_shims();
-
-// node_modules/@opentask/taskin-task-server-mcp/dist/task-server-mcp.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 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;
-    });
+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;
   }
-  /**
-   * 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`);
-    }
+}
+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;
   }
-  /**
-   * Get server information
-   */
-  getServerInfo() {
-    return {
-      name: this.config.name,
-      version: this.config.version,
-      protocolVersion: "2024-11-05",
-      capabilities: {
-        tools: {},
-        prompts: {},
-        resources: {}
-      }
-    };
+  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"] };
   }
-  /**
-   * 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"]
+}
+
+// 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);
+    };
+    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 "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);
+        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
-
-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:
+  return mcpCommandFor(manager);
+}
 
-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/index.ts
+init_esm_shims();
 
-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/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;
   }
-  /**
-   * 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);
+}
+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;
   }
-  /** 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 }
-    };
+}
+
+// src/commands/mcp-install.ts
+var ARQUIVO = ".mcp.json";
+function lerSeExistir(caminho) {
+  try {
+    return readFileSync5(caminho, "utf-8");
+  } catch {
+    return void 0;
   }
-  async handleListTasks(args) {
-    const tarefas = await this.selecionarTarefas(_TaskMCPServer.criterioDe(args));
-    return {
-      content: [{ type: "text", text: JSON.stringify(tarefas, null, 2) }],
-      isError: false
-    };
+}
+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") {
-      const tarefas = await this.selecionarTarefas({});
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(tarefas, null, 2)
-          }
-        ]
-      };
-    }
-    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"
@@ -6233,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("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("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);
@@ -6279,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);
       }
@@ -6316,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) => {
@@ -6391,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, {
@@ -6428,7 +6816,7 @@ async function createTask(options, gitService) {
         taskId,
         title: options.title,
         defaultBranch: behavior.defaultBranch,
-        ciSkipTag: behavior.ciSkipTag
+        ciSkipTag
       });
     } catch (pushError) {
       error(
@@ -6750,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) => {
@@ -6781,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,
@@ -6874,10 +7267,7 @@ async function reviewTask(taskId, options) {
   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"
@@ -6950,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);
@@ -6976,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();
@@ -7011,7 +7406,7 @@ 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) {
@@ -7037,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");
   }
 }
@@ -7047,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",
@@ -7079,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);
@@ -7251,6 +7646,7 @@ var EXEMPLOS = {
   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"]
 };
@@ -7334,7 +7730,7 @@ function showCustomHelp(program2) {
 
 // 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);
@@ -7342,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";
@@ -7715,6 +8111,7 @@ configCommand(program);
 registerExportCommand(program);
 lintCommand(program);
 dashboardCommand(program);
+mcpInstallCommand(program);
 mcpServerCommand(program);
 notifyCommand(program);
 program.on("option:help", () => {