@andre.buzeli/git-mcp 16.1.3 → 16.1.6

package/src/tools/git-merge.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, createError, handleEmptyCall } from "../utils/errors.js";
 import { validateProjectPath } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -68,8 +68,11 @@ SQUASH:
 - Útil para manter histórico limpo`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-merge", { projectPath: "/path/to/project", action: "status" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action } = args;
     
     try {
@@ -98,11 +101,13 @@ SQUASH:
         // Pre-merge check: working tree status
         const status = await git.status(projectPath);
         if (!status.isClean) {
-          // We could warn or fail. Standard git refuses merge if changes would be overwritten.
-          // Let's just warn in logs or return error if critical?
-          // Git will fail anyway if conflicts with local changes.
-          // Let's inform the user.
-          console.warn("[GitMerge] Working tree not clean. Merge might fail.");
+            return asToolError("DIRTY_WORKING_TREE",
+                "Working tree com alterações não commitadas. Faça commit ou stash antes de mergear.", {
+                modified: status.modified,
+                staged: status.staged,
+                notAdded: status.not_added,
+                suggestion: "Use git-workflow action='update' para commitar as mudanças, ou git-stash para guardá-las temporariamente"
+            });
         }
 
         const currentBranch = await git.getCurrentBranch(projectPath);

package/src/tools/git-pulls.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import axios from "axios";
-import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, handleEmptyCall } from "../utils/errors.js";
 import { getRepoNameFromPath, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
@@ -76,8 +76,11 @@ AÇÕES:
 NOTA: O PR é criado em AMBOS os providers simultaneamente.`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-pulls", { projectPath: "/path/to/project", action: "list" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     validateProjectPath(args.projectPath);
     const repo = getRepoNameFromPath(args.projectPath);
     try {

package/src/tools/git-remote.js

@@ -3,7 +3,7 @@ import axios from "axios";
 import fs from "node:fs";
 import path from "node:path";
 import archiver from "archiver";
-import { asToolError, asToolResult, errorToResponse, mapExternalError } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, mapExternalError, handleEmptyCall } from "../utils/errors.js";
 import { getRepoNameFromPath, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 import { sendLog, requestConfirmation } from "../utils/mcpNotify.js";
@@ -167,7 +167,11 @@ ARQUIVOS VIA API:
       },
       content: {
         type: "string",
-        description: "Conteúdo do arquivo para contents-create"
+        description: "Conteúdo do arquivo para contents-create (texto simples, será convertido para base64 automaticamente)"
+      },
+      message: {
+        type: "string",
+        description: "Mensagem do commit para contents-create. Default: 'Add {path}'"
       },
       branch: {
         type: "string",
@@ -214,8 +218,11 @@ QUANDO USAR:
 - Para configurar tópicos: use action='topics-set'`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-remote", { projectPath: "/path/to/project", action: "list" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action } = args;
     try {
       validateProjectPath(projectPath);

package/src/tools/git-reset.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, handleEmptyCall } from "../utils/errors.js";
 import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 import { sendLog, requestConfirmation } from "../utils/mcpNotify.js";
 
@@ -57,8 +57,11 @@ REFERÊNCIAS:
 - abc1234: SHA específico do commit`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-reset", { projectPath: "/path/to/project", action: "soft", ref: "HEAD~1" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action, ref } = args;
     try {
       validateProjectPath(projectPath);

package/src/tools/git-stash.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, handleEmptyCall } from "../utils/errors.js";
 import { validateProjectPath } from "../utils/repoHelpers.js";
 import { withRetry } from "../utils/retry.js";
 
@@ -67,8 +67,11 @@ AÇÕES:
 - clear: Remover todos os stashes`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-stash", { projectPath: "/path/to/project", action: "list" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action } = args;
     try {
       validateProjectPath(projectPath);

package/src/tools/git-sync.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, handleEmptyCall } from "../utils/errors.js";
 import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -54,8 +54,11 @@ FLUXO RECOMENDADO:
 NOTA: Se pull falhar com conflito, resolva manualmente e faça commit.`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-sync", { projectPath: "/path/to/project", action: "fetch" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action } = args;
     try {
       validateProjectPath(projectPath);

package/src/tools/git-tags.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, handleEmptyCall } from "../utils/errors.js";
 import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -61,8 +61,11 @@ FLUXO TÍPICO:
 2. git-tags push tag='v1.0.0'`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-tags", { projectPath: "/path/to/project", action: "list" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    if (!validate(args)) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action } = args;
     try {
       validateProjectPath(projectPath);

package/src/tools/git-workflow.js

@@ -1,8 +1,9 @@
 import Ajv from "ajv";
 import fs from "fs";
 import path from "path";
-import { asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, createError, handleEmptyCall } from "../utils/errors.js";
 import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+import { resolveWorktreeContext, isProtectedPath } from "../utils/worktreeResolver.js";
 import { sendLog } from "../utils/mcpNotify.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -133,13 +134,41 @@ EXEMPLOS DE USO:
 • Ver mudanças: { "projectPath": "/path/to/project", "action": "status" }`;
 
   async function handle(args) {
+    // Call vazia = modelo tentando descobrir o schema. Retorna help em vez de erro.
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-workflow", { projectPath: "/path/to/project", action: "update", message: "feat: descrição" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) {
+    if (!validate(args)) {
       return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     }
     const { projectPath, action } = args;
+    let effectivePath = projectPath;
+    let worktreeCtx = null;
+
     try {
       validateProjectPath(projectPath);
+
+      if (action === "init") {
+          if (isProtectedPath(projectPath)) {
+              return asToolError("PROTECTED_PATH", `Não é permitido criar repositório git em ${projectPath}`);
+          }
+      } else {
+          worktreeCtx = await resolveWorktreeContext(projectPath, git);
+          effectivePath = worktreeCtx.worktreePath;
+
+          // Ajustar paths relativos se estivermos rodando da raiz
+          if (effectivePath !== projectPath && Array.isArray(args.files)) {
+              const rel = path.relative(effectivePath, projectPath);
+              args.files = args.files.map(f => {
+                  if (path.isAbsolute(f)) return f;
+                  // Se for ".", vira o próprio diretório relativo
+                  if (f === ".") return rel.replace(/\\/g, '/');
+                  return path.join(rel, f).replace(/\\/g, '/');
+              });
+          }
+      }
+
       if (action === "init") {
         const shouldCreateGitignore = args.createGitignore !== false;
 
@@ -148,37 +177,37 @@ EXEMPLOS DE USO:
             success: true,
             dryRun: true,
             message: "DRY RUN: Repositório seria inicializado localmente e nos providers",
-            repoName: getRepoNameFromPath(projectPath),
+            repoName: getRepoNameFromPath(effectivePath),
             gitignoreCreated: shouldCreateGitignore
           });
         }
 
-        const isRepo = await git.isRepo(projectPath);
+        const isRepo = await git.isRepo(effectivePath);
         if (!isRepo) {
-          await git.init(projectPath);
+          await git.init(effectivePath);
         }
 
         // Criar .gitignore baseado no tipo de projeto (apenas se não existir ou se for novo repo)
         let gitignoreCreated = false;
 
         if (shouldCreateGitignore) {
-          const hasGitignore = fs.existsSync(path.join(projectPath, ".gitignore"));
+          const hasGitignore = fs.existsSync(path.join(effectivePath, ".gitignore"));
           if (!hasGitignore) {
-            const projectType = detectProjectType(projectPath);
+            const projectType = detectProjectType(effectivePath);
             const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
-            await git.createGitignore(projectPath, patterns);
+            await git.createGitignore(effectivePath, patterns);
             gitignoreCreated = true;
           }
         }
 
-        const repo = getRepoNameFromPath(projectPath);
+        const repo = getRepoNameFromPath(effectivePath);
         const isPublic = args.isPublic === true; // Default: privado
         const organization = args.organization || undefined;
         const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
 
         // Configurar remotes com org se fornecida
         const urls = await pm.getRemoteUrls(repo, organization);
-        await git.ensureRemotes(projectPath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
+        await git.ensureRemotes(effectivePath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
 
         return asToolResult({
           success: true,
@@ -190,7 +219,7 @@ EXEMPLOS DE USO:
         });
       }
       if (action === "status") {
-        const st = await git.status(projectPath);
+        const st = await git.status(effectivePath);
 
         if (args.dryRun) {
           return asToolResult({
@@ -224,7 +253,15 @@ EXEMPLOS DE USO:
           _aiContext.suggestedAction = "Working tree limpa. Modifique arquivos ou use action='push' se há commits pendentes";
         }
 
-        return asToolResult({ ...st, _aiContext }, { tool: 'workflow', action: 'status' });
+        const result = { ...st, _aiContext };
+        if (worktreeCtx?.isWorktree) {
+            result._worktreeContext = {
+                detected: true,
+                repoRoot: worktreeCtx.repoRoot,
+                branch: worktreeCtx.branch
+            };
+        }
+        return asToolResult(result, { tool: 'workflow', action: 'status' });
       }
       if (action === "add") {
         const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
@@ -238,12 +275,12 @@ EXEMPLOS DE USO:
           });
         }
 
-        await git.add(projectPath, files);
+        await git.add(effectivePath, files);
         return asToolResult({ success: true, files }, { tool: 'workflow', action: 'add' });
       }
       if (action === "remove") {
         const files = Array.isArray(args.files) ? args.files : [];
-        await git.remove(projectPath, files);
+        await git.remove(effectivePath, files);
         return asToolResult({ success: true, files });
       }
       if (action === "commit") {
@@ -259,12 +296,20 @@ EXEMPLOS DE USO:
           });
         }
 
-        const sha = await git.commit(projectPath, args.message);
+        const st = await git.status(effectivePath);
+        if (!st.staged || st.staged.length === 0) {
+            return asToolError("NOTHING_TO_COMMIT", "Nenhum arquivo staged para commitar", {
+                suggestion: "Use action='add' com files=['.'] para adicionar arquivos ao staging antes de commitar",
+                status: { modified: st.modified, notAdded: st.not_added }
+            });
+        }
+
+        const sha = await git.commit(effectivePath, args.message);
         return asToolResult({ success: true, sha, message: args.message }, { tool: 'workflow', action: 'commit' });
       }
       if (action === "clean") {
         if (args.dryRun) {
-          const result = await git.cleanUntracked(projectPath);
+          const result = await git.cleanUntracked(effectivePath);
           return asToolResult({
             success: true,
             dryRun: true,
@@ -273,7 +318,7 @@ EXEMPLOS DE USO:
           });
         }
 
-        const result = await git.cleanUntracked(projectPath);
+        const result = await git.cleanUntracked(effectivePath);
         return asToolResult({
           success: true,
           ...result,
@@ -283,7 +328,7 @@ EXEMPLOS DE USO:
         });
       }
       if (action === "ensure-remotes") {
-        const repo = getRepoNameFromPath(projectPath);
+        const repo = getRepoNameFromPath(effectivePath);
         const isPublic = args.isPublic === true; // Default: privado
         const organization = args.organization || undefined;
 
@@ -310,12 +355,12 @@ EXEMPLOS DE USO:
         const giteaBase = pm.giteaUrl?.replace(/\/$/, "");
         const giteaUrl = ensured.gitea?.ok && ensured.gitea.repo && giteaBase
           ? `${giteaBase}/${ensured.gitea.repo}.git` : "";
-        await git.ensureRemotes(projectPath, { githubUrl, giteaUrl, organization });
-        const remotes = await git.listRemotes(projectPath);
+        await git.ensureRemotes(effectivePath, { githubUrl, giteaUrl, organization });
+        const remotes = await git.listRemotes(effectivePath);
         return asToolResult({ success: true, ensured, remotes, isPrivate: !isPublic, organization: organization || undefined }, { tool: 'workflow', action: 'ensure-remotes' });
       }
       if (action === "push") {
-        const branch = await git.getCurrentBranch(projectPath);
+        const branch = await git.getCurrentBranch(effectivePath);
         const force = !!args.force;
 
         if (args.dryRun) {
@@ -335,7 +380,7 @@ EXEMPLOS DE USO:
 
         // Retry logic for push (often fails due to network or concurrent updates)
         const result = await withRetry(
-          () => git.pushParallel(projectPath, branch, force, organization),
+          () => git.pushParallel(effectivePath, branch, force, organization),
           3,
           "push"
         );
@@ -350,15 +395,15 @@ EXEMPLOS DE USO:
         }
         
         const channel = args.channel || "production";
-        const wtPath = path.join(projectPath, branch);
+        const wtPath = path.join(projectPath, branch); // Cria relativo ao path original solicitado
 
         if (fs.existsSync(wtPath)) {
             return asToolError("WORKTREE_PATH_EXISTS", `Diretório '${wtPath}' já existe.`, { suggestion: "Use git-worktree add se quiser configurar path customizado" });
         }
 
         try {
-            await git.addWorktree(projectPath, branch, wtPath);
-            await git.setWorktreeConfig(projectPath, branch, { path: wtPath, channel });
+            await git.addWorktree(effectivePath, branch, wtPath);
+            await git.setWorktreeConfig(effectivePath, branch, { path: wtPath, channel });
             
             return asToolResult({
                 success: true,
@@ -390,13 +435,13 @@ EXEMPLOS DE USO:
           if (args.dryRun) {
             gitignored = gitignorePatterns;
           } else {
-            await git.addToGitignore(projectPath, gitignorePatterns);
+            await git.addToGitignore(effectivePath, gitignorePatterns);
             gitignored = gitignorePatterns;
           }
         }
 
         // 1. Status para ver o que mudou
-        const status = await git.status(projectPath);
+        const status = await git.status(effectivePath);
 
         const hasChanges = !status.isClean ||
           (status.not_added?.length > 0) ||
@@ -438,15 +483,15 @@ EXEMPLOS DE USO:
         }
 
         // 2. Add
-        await git.add(projectPath, files);
+        await git.add(effectivePath, files);
 
         // 3. Commit  
-        const sha = await git.commit(projectPath, args.message);
+        const sha = await git.commit(effectivePath, args.message);
 
         // 3.5. Garantir remotes com organization (se fornecida)
         const organization = args.organization || undefined;
         if (organization) {
-          const repo = getRepoNameFromPath(projectPath);
+          const repo = getRepoNameFromPath(effectivePath);
           const isPublic = args.isPublic === true;
           const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
           // Build URLs from actual ensureRepos results (handles GitHub fallback to personal account)
@@ -455,11 +500,11 @@ EXEMPLOS DE USO:
           const giteaBase = pm.giteaUrl?.replace(/\/$/, "");
           const giteaUrl = ensured.gitea?.ok && ensured.gitea.repo && giteaBase
             ? `${giteaBase}/${ensured.gitea.repo}.git` : "";
-          await git.ensureRemotes(projectPath, { githubUrl, giteaUrl, organization });
+          await git.ensureRemotes(effectivePath, { githubUrl, giteaUrl, organization });
         }
 
         // 4. Push Strategy
-        const branch = await git.getCurrentBranch(projectPath);
+        const branch = await git.getCurrentBranch(effectivePath);
         let pushResult = {};
         let synced = [];
         let errors = [];
@@ -467,7 +512,7 @@ EXEMPLOS DE USO:
         // Determine Channel
         let channel = args.channel;
         if (!channel) {
-             const storedChannel = await git.getConfig(projectPath, `worktree-branch.${branch}.channel`);
+             const storedChannel = await git.getConfig(effectivePath, `worktree-branch.${branch}.channel`);
              if (storedChannel) channel = storedChannel;
         }
         
@@ -477,13 +522,13 @@ EXEMPLOS DE USO:
         // SYNC BRANCHES
         if (syncBranches) {
             // Só permitido no principal (onde .git é diretório)
-            if (fs.existsSync(path.join(projectPath, ".git")) && fs.statSync(path.join(projectPath, ".git")).isFile()) {
+            if (fs.existsSync(path.join(effectivePath, ".git")) && fs.statSync(path.join(effectivePath, ".git")).isFile()) {
                 return asToolError("INVALID_OPERATION", "syncBranches=true só pode ser executado a partir do repositório principal, não de um worktree.");
             }
 
             // 1. Push do principal (current)
             const remoteBranch = resolveRemoteBranch(branch, channel);
-            const remotes = await git.listRemotes(projectPath);
+            const remotes = await git.listRemotes(effectivePath);
             
             await sendLog(server, "info", "update: push iniciado (sync)", { branch, remoteBranch, force });
 
@@ -491,7 +536,7 @@ EXEMPLOS DE USO:
             const mainFailed = [];
             for (const r of remotes) {
                 try {
-                    await git.pushRefspec(projectPath, r.remote, branch, remoteBranch, force);
+                    await git.pushRefspec(effectivePath, r.remote, branch, remoteBranch, force);
                     mainPushed.push(r.remote);
                 } catch(e) {
                     mainFailed.push({ remote: r.remote, error: e.message });
@@ -501,7 +546,7 @@ EXEMPLOS DE USO:
             // 2. Propagar para worktrees
             // Req 8.3: synced.length + errors.length === N (número de worktrees registrados)
             // O principal NÃO entra no contador — só os worktrees registrados
-            const configs = await git.getWorktreeConfigs(projectPath);
+            const configs = await git.getWorktreeConfigs(effectivePath);
             
             for (const wt of configs) {
                 // Pula se for a própria branch principal (caso esteja registrada)
@@ -538,13 +583,13 @@ EXEMPLOS DE USO:
                 // Comportamento padrão (production)
                 await sendLog(server, "info", "update: push iniciado", { branch, force });
                 pushResult = await withRetry(
-                  () => git.pushParallel(projectPath, branch, force, organization),
+                  () => git.pushParallel(effectivePath, branch, force, organization),
                   3,
                   "push"
                 );
             } else {
                 // Comportamento customizado (beta/alpha) -> pushRefspec
-                const remotes = await git.listRemotes(projectPath);
+                const remotes = await git.listRemotes(effectivePath);
                 
                 const pushed = [];
                 const failed = [];
@@ -553,7 +598,7 @@ EXEMPLOS DE USO:
 
                 for (const r of remotes) {
                     try {
-                        await git.pushRefspec(projectPath, r.remote, branch, remoteBranch, force);
+                        await git.pushRefspec(effectivePath, r.remote, branch, remoteBranch, force);
                         pushed.push(r.remote);
                     } catch (e) {
                         failed.push({ remote: r.remote, error: e.message });
@@ -568,7 +613,7 @@ EXEMPLOS DE USO:
             }
         }
 
-        return asToolResult({
+        const result = {
           success: true,
           action: "update",
           steps: ["status", "add", "commit", "push"],
@@ -583,7 +628,17 @@ EXEMPLOS DE USO:
             completed: true,
             message: "Ciclo completo: arquivos adicionados, commit criado e push realizado" + (organization ? ` [org: ${organization}]` : "")
           }
-        }, { tool: 'workflow', action: 'update' });
+        };
+
+        if (worktreeCtx?.isWorktree) {
+             result._worktreeContext = {
+                 detected: true,
+                 repoRoot: worktreeCtx.repoRoot,
+                 branch: worktreeCtx.branch
+             };
+        }
+
+        return asToolResult(result, { tool: 'workflow', action: 'update' });
       }
 
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, {