@rethunk/mcp-multi-root-git 2.9.1 → 4.0.0

package/dist/server/git-grep-tool.js

@@ -0,0 +1,188 @@
+import { basename } from "node:path";
+import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
+import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitTopLevel, spawnGitAsync } from "./git.js";
+import { isSafeGitAncestorRef } from "./git-refs.js";
+import { jsonRespond, spreadWhen } from "./json.js";
+import { requireGitAndRoots } from "./roots.js";
+import { RootPickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_MATCHES_HARD_CAP = 1000;
+const DEFAULT_MAX_MATCHES = 200;
+/** Run `git log -S` / `-G` pickaxe history search for a single repo root. */
+async function runPickaxe(opts) {
+    const { top, mode, term, ref, paths, ignoreCase, maxMatches } = opts;
+    const args = [
+        "log",
+        "--pretty=format:%H%x01%s",
+        "-n",
+        String(maxMatches + 1),
+        mode === "S" ? "-S" : "-G",
+        term,
+    ];
+    // `-i` / `--regexp-ignore-case` affects `-G` (and `--grep`); harmless on `-S`.
+    if (ignoreCase)
+        args.push("-i");
+    if (ref)
+        args.push(ref);
+    if (paths.length > 0)
+        args.push("--", ...paths);
+    const r = await spawnGitAsync(top, args);
+    if (!r.ok) {
+        return {
+            error: ERROR_CODES.GIT_GREP_FAILED,
+            detail: r.stderr.trim() || r.stdout.trim(),
+        };
+    }
+    const commits = [];
+    for (const line of r.stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const sep = line.indexOf("\x01");
+        if (sep < 0)
+            continue;
+        const sha = line.slice(0, sep).trim();
+        const subject = line.slice(sep + 1).trim();
+        if (sha)
+            commits.push({ sha, subject });
+    }
+    const truncated = commits.length > maxMatches;
+    return {
+        commits: truncated ? commits.slice(0, maxMatches) : commits,
+        truncated,
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderGrepMarkdown(group) {
+    const lines = [`### ${group.repo}`, `_root: ${group.root}_`, ""];
+    if (group.error) {
+        lines.push(`_error: ${group.error}${group.detail ? ` — ${group.detail}` : ""}_`);
+        return lines.join("\n");
+    }
+    const commits = group.commits ?? [];
+    if (commits.length === 0) {
+        lines.push("_(no pickaxe hits)_");
+    }
+    else {
+        for (const c of commits) {
+            lines.push(`- \`${c.sha.slice(0, 7)}\`  ${c.subject}`);
+        }
+    }
+    if (group.truncated) {
+        lines.push("", "_(truncated — raise `maxMatches` for the full result set)_");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitGrepTool(server) {
+    server.addTool({
+        name: "git_grep",
+        description: "Pickaxe history search across one or more roots: which commits added or removed a term " +
+            '(`git log -S`) or changed lines matching a regex (`git log -G`), via `pickaxe: { mode: "S"|"G", term }`. ' +
+            "Returns `commits[]` (sha + subject) per root. Set `ref` to limit history to that tip. " +
+            "For working-tree content search use the client's native grep/rg tooling instead — " +
+            "content mode was removed in v6.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: RootPickSchema.extend({
+            pickaxe: z
+                .object({
+                mode: z
+                    .enum(["S", "G"])
+                    .describe("`S` = pickaxe string (`git log -S`); `G` = pickaxe regex (`git log -G`)."),
+                term: z.string().min(1).max(500).describe("Search term / regex for pickaxe history."),
+            })
+                .describe("Pickaxe history search. Returns `commits[]` (sha + subject) per root."),
+            ref: z
+                .string()
+                .optional()
+                .describe("Commit/branch/tag to use as the history tip. Must be a safe ref token."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Limit history to these paths (must resolve within the repo root)."),
+            ignoreCase: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Case-insensitive match (`-i`; affects `G` mode regexes)."),
+            maxMatches: z
+                .number()
+                .int()
+                .min(1)
+                .max(MAX_MATCHES_HARD_CAP)
+                .optional()
+                .default(DEFAULT_MAX_MATCHES)
+                .describe(`Max commits per root (hard cap ${MAX_MATCHES_HARD_CAP}, default ${DEFAULT_MAX_MATCHES}).`),
+        }),
+        execute: async (args) => {
+            const pre = requireGitAndRoots(server, args, undefined);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const pickaxe = args.pickaxe;
+            if (args.ref !== undefined && !isSafeGitAncestorRef(args.ref)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
+            }
+            const ref = args.ref?.trim() || undefined;
+            const rawPaths = Array.isArray(args.paths) ? args.paths : [];
+            const ignoreCase = args.ignoreCase ?? false;
+            const maxMatches = Math.min(args.maxMatches ?? DEFAULT_MAX_MATCHES, MAX_MATCHES_HARD_CAP);
+            // Fan out across roots. Path confinement is per-root since each root has
+            // its own git toplevel.
+            const jobs = pre.roots.map((rootInput) => ({ rootInput }));
+            const groups = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, async ({ rootInput }) => {
+                const top = gitTopLevel(rootInput);
+                if (!top) {
+                    return {
+                        root: rootInput,
+                        repo: basename(rootInput),
+                        error: ERROR_CODES.NOT_A_GIT_REPOSITORY,
+                        detail: rootInput,
+                    };
+                }
+                for (const p of rawPaths) {
+                    const resolved = resolvePathForRepo(p, top);
+                    if (!assertRelativePathUnderTop(p, resolved, top)) {
+                        return {
+                            root: top,
+                            repo: basename(top),
+                            error: ERROR_CODES.PATH_ESCAPES_REPO,
+                            detail: p,
+                        };
+                    }
+                }
+                const result = await runPickaxe({
+                    top,
+                    mode: pickaxe.mode,
+                    term: pickaxe.term,
+                    ref,
+                    paths: rawPaths,
+                    ignoreCase,
+                    maxMatches,
+                });
+                if ("error" in result) {
+                    return { root: top, repo: basename(top), error: result.error, detail: result.detail };
+                }
+                return {
+                    root: top,
+                    repo: basename(top),
+                    commits: result.commits,
+                    ...spreadWhen(result.truncated, { truncated: true }),
+                };
+            });
+            if (args.format === "json") {
+                return jsonRespond({ results: groups });
+            }
+            const mdChunks = ["# git grep", ...groups.map((g) => renderGrepMarkdown(g))];
+            return mdChunks.join("\n\n");
+        },
+    });
+}

package/dist/server/git-inventory-tool.js

@@ -1,19 +1,20 @@
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitRevParseGitDir, gitTopLevel, isSafeGitUpstreamToken, } from "./git.js";
+import { isSafeGitAncestorRef } from "./git-refs.js";
 import { buildInventorySectionMarkdown, collectInventoryEntry, makeSkipEntry, validateRepoPath, } from "./inventory.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { applyPresetNestedRoots } from "./presets.js";
 import { requireGitAndRoots } from "./roots.js";
-import { MAX_INVENTORY_ROOTS_DEFAULT, WorkspacePickSchema } from "./schemas.js";
+import { MAX_INVENTORY_ROOTS_DEFAULT, RootPickSchema } from "./schemas.js";
 export function registerGitInventoryTool(server) {
     server.addTool({
         name: "git_inventory",
-        description: "Read-only status + ahead/behind per root.",
+        description: "Read-only status + ahead/behind per root. Optional `compareRefs` adds ahead/behind between two local refs (independent of upstream).",
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: RootPickSchema.extend({
             nestedRoots: z.array(z.string()).optional(),
             preset: z.string().optional(),
             presetMerge: z
@@ -23,12 +24,19 @@ export function registerGitInventoryTool(server) {
                 .describe("Merge with preset instead of replacing."),
             remote: z.string().optional().describe("Pair with `branch`."),
             branch: z.string().optional().describe("Pair with `remote`."),
+            compareRefs: z
+                .object({
+                left: z.string().describe("Base ref (ahead = commits in right not in left)."),
+                right: z.string().describe("Other ref (behind = commits in left not in right)."),
+            })
+                .optional()
+                .describe("Ahead/behind between two local refs (e.g. main vs a feature branch), independent of upstream tracking."),
             maxRoots: z.number().int().min(1).max(256).optional().default(MAX_INVENTORY_ROOTS_DEFAULT),
         }),
         execute: async (args) => {
-            if (args.absoluteGitRoots != null && args.absoluteGitRoots.length > 0) {
+            if (Array.isArray(args.root)) {
                 if (args.preset || (args.nestedRoots?.length ?? 0) > 0) {
-                    return jsonRespond({ error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_NESTED_OR_PRESET_CONFLICT });
+                    return jsonRespond({ error: ERROR_CODES.ROOT_LIST_NESTED_OR_PRESET_CONFLICT });
                 }
             }
             const pre = requireGitAndRoots(server, args, args.preset);
@@ -49,24 +57,36 @@ export function registerGitInventoryTool(server) {
                 }
                 upstream = { mode: "fixed", remote: rawRemote, branch: rawBranch };
             }
+            let compareRefs;
+            if (args.compareRefs) {
+                const left = args.compareRefs.left.trim();
+                const right = args.compareRefs.right.trim();
+                if (!isSafeGitAncestorRef(left) || !isSafeGitAncestorRef(right)) {
+                    return jsonRespond({
+                        error: ERROR_CODES.UNSAFE_REF_TOKEN,
+                        left: args.compareRefs.left,
+                        right: args.compareRefs.right,
+                    });
+                }
+                compareRefs = { left, right };
+            }
             const useFixed = upstream.mode === "fixed";
             const allJson = [];
             const mdChunks = [];
             for (const workspaceRoot of pre.roots) {
                 const top = gitTopLevel(workspaceRoot);
                 if (!top) {
-                    const err = { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: workspaceRoot };
                     if (args.format === "json") {
                         allJson.push({
                             workspaceRoot: workspaceRoot,
                             ...(upstream.mode === "fixed" ? { upstream } : {}),
                             entries: [
-                                makeSkipEntry(workspaceRoot, workspaceRoot, upstream.mode, JSON.stringify(err)),
+                                makeSkipEntry(workspaceRoot, workspaceRoot, upstream.mode, "(not a git repository)"),
                             ],
                         });
                     }
                     else {
-                        mdChunks.push(`### ${workspaceRoot}\n${jsonRespond(err)}`);
+                        mdChunks.push(`### ${workspaceRoot}\n(not a git repository)`);
                     }
                     continue;
                 }
@@ -106,14 +126,14 @@ export function registerGitInventoryTool(server) {
                         }
                         jobs.push({ label: rel, abs });
                     }
-                    const computed = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, (j) => collectInventoryEntry(j.label, j.abs, upstream.remote, upstream.branch));
+                    const computed = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, (j) => collectInventoryEntry(j.label, j.abs, upstream.remote, upstream.branch, compareRefs));
                     entries.push(...computed);
                 }
                 else if (!gitRevParseGitDir(top)) {
                     entries.push(makeSkipEntry(".", top, upstream.mode, "(not a git work tree — unexpected)"));
                 }
                 else {
-                    const one = await collectInventoryEntry(".", top, upstream.remote, upstream.branch);
+                    const one = await collectInventoryEntry(".", top, upstream.remote, upstream.branch, compareRefs);
                     entries.push(one);
                 }
                 if (args.format === "json") {

package/dist/server/git-log-tool.js

@@ -1,11 +1,12 @@
 import { basename } from "node:path";
 import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
 import { ERROR_CODES } from "./error-codes.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitTopLevel, spawnGitAsync } from "./git.js";
 import { isSafeGitAncestorRef } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireGitAndRoots } from "./roots.js";
-import { WorkspacePickSchema } from "./schemas.js";
+import { RootPickSchema } from "./schemas.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -21,7 +22,7 @@ const RECORD_SEP_OUT = "\x02"; // what git outputs (STX) — used as record-STAR
 // %x02 is placed at the START of each record (tformat adds \n as terminator after each).
 // Splitting stdout on \x02 then gives empty-first-chunk + one chunk per commit,
 // each structured as:  <fields>\x01\n\n <shortstat text>\n
-// Fields are separated by %x01; the trailing \x01 before \n leaves one empty last field (ignored).
+// Fields are separated by %x01; the trailing %x01 before \n leaves one empty last field (ignored).
 const PRETTY_FORMAT = "%x02%H%x01%s%x01%aN%x01%aE%x01%aI%x01";
 // ---------------------------------------------------------------------------
 // Helpers
@@ -55,7 +56,7 @@ async function gitCurrentBranch(cwd, branchArg) {
  * Run git log for a single repo root and return structured data.
  */
 async function runGitLog(opts) {
-    const { top, since, paths, grep, author, maxCommits, branch } = opts;
+    const { top, since, paths, grep, author, maxCommits, branch, follow } = opts;
     // Resolve branch first (needed for output metadata).
     const resolvedBranch = await gitCurrentBranch(top, branch);
     // Fetch one extra commit to detect truncation.
@@ -68,6 +69,9 @@ async function runGitLog(opts) {
         String(fetchLimit),
         `--since=${since}`,
     ];
+    if (follow) {
+        logArgs.push("--follow");
+    }
     if (branch?.trim()) {
         logArgs.push(branch.trim());
     }
@@ -176,11 +180,12 @@ function renderLogMarkdown(group, filterSummary) {
 export function registerGitLogTool(server) {
     server.addTool({
         name: "git_log",
-        description: "Read-only `git log` across one or more roots. Returns author, date, subject, optional diff stats.",
+        description: "Read-only `git log` across one or more roots. Returns author, date, subject, optional diff stats. " +
+            "`follow: true` passes `--follow` for rename-aware history (requires exactly one `paths` entry).",
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: RootPickSchema.extend({
             format: z
                 .enum(["markdown", "json", "oneline"])
                 .optional()
@@ -209,6 +214,11 @@ export function registerGitLogTool(server) {
                 .default(DEFAULT_MAX_COMMITS)
                 .describe(`Max commits per root (hard cap ${MAX_COMMITS_HARD_CAP}, default ${DEFAULT_MAX_COMMITS}).`),
             branch: z.string().optional().describe("Ref/branch to log from. Default: HEAD."),
+            follow: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Pass `git log --follow` for rename-aware history. Requires exactly one entry in `paths`."),
         }),
         execute: async (args) => {
             const pre = requireGitAndRoots(server, args, undefined);
@@ -227,12 +237,20 @@ export function registerGitLogTool(server) {
                     return jsonRespond({ error: ERROR_CODES.INVALID_PATHS, path: p });
                 }
             }
+            const follow = args.follow ?? false;
+            if (follow && rawPaths.length !== 1) {
+                return jsonRespond({
+                    error: ERROR_CODES.INVALID_PATHS,
+                    detail: "follow requires exactly one path",
+                    pathCount: rawPaths.length,
+                });
+            }
             // Validate branch — reject leading-dash and other injection attempts.
             if (args.branch && !isSafeGitAncestorRef(args.branch)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, branch: args.branch });
             }
             const maxCommits = Math.min(args.maxCommits ?? DEFAULT_MAX_COMMITS, MAX_COMMITS_HARD_CAP);
-            // Fan out across roots.
+            // Fan out across roots. Path confinement is per-root (each has its own toplevel).
             const jobs = pre.roots.map((rootInput) => ({ rootInput }));
             const results = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, async ({ rootInput }) => {
                 const top = gitTopLevel(rootInput);
@@ -243,6 +261,16 @@ export function registerGitLogTool(server) {
                         error: ERROR_CODES.NOT_A_GIT_REPOSITORY,
                     };
                 }
+                for (const p of rawPaths) {
+                    const resolved = resolvePathForRepo(p, top);
+                    if (!assertRelativePathUnderTop(p, resolved, top)) {
+                        return {
+                            _error: true,
+                            workspaceRoot: rootInput,
+                            error: ERROR_CODES.PATH_ESCAPES_REPO,
+                        };
+                    }
+                }
                 const r = await runGitLog({
                     top,
                     since: rawSince,
@@ -251,6 +279,7 @@ export function registerGitLogTool(server) {
                     author: args.author,
                     maxCommits,
                     branch: args.branch,
+                    follow,
                 });
                 if ("error" in r) {
                     return { _error: true, workspaceRoot: rootInput, error: r.error };
@@ -261,6 +290,8 @@ export function registerGitLogTool(server) {
             const filterParts = [`since: ${rawSince}`];
             if (rawPaths.length > 0)
                 filterParts.push(`paths: ${rawPaths.join(", ")}`);
+            if (follow)
+                filterParts.push("follow");
             if (args.grep)
                 filterParts.push(`grep: ${args.grep}`);
             if (args.author)

package/dist/server/git-merge-tool.js

@@ -15,22 +15,39 @@ const StrategySchema = z
     .describe("`auto` (default): cascade fast-forward → rebase → merge-commit per source. " +
     "`ff-only`: only fast-forward, fail if diverged. " +
     "`rebase`: rebase source onto destination, then fast-forward (no merge-commit fallback). " +
-    "`merge`: always create a merge commit (no fast-forward).");
+    "`merge`: always create a merge commit (no fast-forward). " +
+    "Note: `auto`/`rebase` rewrite the source branch tip in place when rebasing (new SHAs).");
 // ---------------------------------------------------------------------------
 // Abort helpers
 // ---------------------------------------------------------------------------
-async function abortMerge(gitTop) {
-    await spawnGitAsync(gitTop, ["merge", "--abort"]);
+/** Result of `git merge --abort` — callers must check `ok` before claiming a clean abort. */
+export async function abortMerge(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["merge", "--abort"]);
+    if (r.ok)
+        return { ok: true };
+    const detail = (r.stderr || r.stdout).trim();
+    return detail === "" ? { ok: false } : { ok: false, detail };
 }
-async function abortRebase(gitTop) {
-    await spawnGitAsync(gitTop, ["rebase", "--abort"]);
+/** Result of `git rebase --abort` — callers must check `ok` before claiming a clean abort. */
+export async function abortRebase(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["rebase", "--abort"]);
+    if (r.ok)
+        return { ok: true };
+    const detail = (r.stderr || r.stdout).trim();
+    return detail === "" ? { ok: false } : { ok: false, detail };
+}
+async function mergeInProgress(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["rev-parse", "--verify", "--quiet", "MERGE_HEAD"]);
+    return r.ok;
 }
 // ---------------------------------------------------------------------------
 // Per-source merge logic
 // ---------------------------------------------------------------------------
 /**
  * Attempt to land `source` on `into`. Caller must ensure `into` is checked out.
- * On conflict the repo state is cleaned (merge/rebase aborted, HEAD restored to `into`).
+ * On conflict the repo is aborted when possible; if `--abort` itself fails the
+ * result carries `merge_abort_failed` / `rebase_abort_failed` and the tree may
+ * still be mid-merge/rebase.
  */
 async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
     // --- Classify state via merge-base ---
@@ -79,6 +96,7 @@ async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
         return mergeCommit(gitTop, source, mergeMessage, into);
     }
     // --- rebase or auto (diverged case) ---
+    // Warning: rebaseSourceOntoInto rewrites the source branch tip in place.
     const rebased = await rebaseSourceOntoInto(gitTop, into, source);
     if (rebased.ok) {
         // Rebase succeeded; FF destination up to the now-rebased source tip.
@@ -96,7 +114,21 @@ async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
 async function fastForward(gitTop, source) {
     const r = await spawnGitAsync(gitTop, ["merge", "--ff-only", source]);
     if (!r.ok) {
-        await abortMerge(gitTop);
+        // ff-only refusal normally leaves no MERGE_HEAD — only abort when mid-merge.
+        if (await mergeInProgress(gitTop)) {
+            const abort = await abortMerge(gitTop);
+            if (!abort.ok) {
+                return {
+                    source,
+                    ok: false,
+                    outcome: "conflicts",
+                    conflictStage: "merge",
+                    conflictPaths: [],
+                    error: ERROR_CODES.MERGE_ABORT_FAILED,
+                    detail: abort.detail ?? (r.stderr || r.stdout).trim(),
+                };
+            }
+        }
         return {
             source,
             ok: false,
@@ -120,7 +152,18 @@ async function mergeCommit(gitTop, source, message, into) {
     const r = await spawnGitAsync(gitTop, ["merge", "--no-ff", "--no-edit", "-m", msg, source]);
     if (!r.ok) {
         const paths = await conflictPaths(gitTop);
-        await abortMerge(gitTop);
+        const abort = await abortMerge(gitTop);
+        if (!abort.ok) {
+            return {
+                source,
+                ok: false,
+                outcome: "conflicts",
+                conflictStage: "merge",
+                conflictPaths: paths,
+                error: ERROR_CODES.MERGE_ABORT_FAILED,
+                detail: abort.detail ?? (r.stderr || r.stdout).trim(),
+            };
+        }
         return {
             source,
             ok: false,
@@ -142,15 +185,27 @@ async function mergeCommit(gitTop, source, message, into) {
 /**
  * Rebase `source` onto `into`, then return to `into`.
  * On failure: abort rebase, check out `into` again, return structured conflict.
+ * Successful rebase rewrites the source branch tip (new SHAs).
  */
 async function rebaseSourceOntoInto(gitTop, into, source) {
     // `git rebase <upstream> <branch>` first switches to <branch>.
     const r = await spawnGitAsync(gitTop, ["rebase", into, source]);
     if (!r.ok) {
         const paths = await conflictPaths(gitTop);
-        await abortRebase(gitTop);
-        // Ensure we're back on `into` regardless of rebase state.
+        const abort = await abortRebase(gitTop);
+        // Ensure we're back on `into` regardless of rebase state (best-effort).
         await spawnGitAsync(gitTop, ["checkout", into]);
+        if (!abort.ok) {
+            return {
+                source,
+                ok: false,
+                outcome: "conflicts",
+                conflictStage: "rebase",
+                conflictPaths: paths,
+                error: ERROR_CODES.REBASE_ABORT_FAILED,
+                detail: abort.detail ?? (r.stderr || r.stdout).trim(),
+            };
+        }
         return {
             source,
             ok: false,
@@ -179,6 +234,9 @@ async function rebaseSourceOntoInto(gitTop, into, source) {
 async function maybeRemoveWorktree(gitTop, source, enabled) {
     if (!enabled)
         return undefined;
+    // Gate on the source branch name first (path basename may be an agent temp dir).
+    if (isProtectedBranch(source))
+        return undefined;
     const path = await worktreeForBranch(gitTop, source);
     if (!path)
         return undefined;
@@ -209,6 +267,7 @@ export function registerGitMergeTool(server) {
         name: "git_merge",
         description: "Merge one or more source branches into a destination. `auto` cascades " +
             "fast-forward → rebase → merge-commit, preferring linear history. " +
+            "`auto`/`rebase` rewrite the source branch tip in place when rebasing (new SHAs), not only the destination. " +
             "Refuses on dirty tree; stops on first conflict. Optional flags delete merged branches/worktrees " +
             "(protected names skipped: main, master, dev, develop, stable, trunk, prod, production, release/*, hotfix/*).",
         annotations: {
@@ -216,7 +275,7 @@ export function registerGitMergeTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             sources: z
                 .array(z.string().min(1))
                 .min(1)
@@ -240,7 +299,7 @@ export function registerGitMergeTool(server) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("Remove local worktrees on source branches after clean merge (`git worktree remove`). Protected tails skipped."),
+                .describe("Remove local worktrees on source branches after clean merge (`git worktree remove`). Protected source names and path tails skipped."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -330,7 +389,6 @@ export function registerGitMergeTool(server) {
                         }),
                         ...spreadWhen(r.branchDeleted === true, { branchDeleted: true }),
                         ...spreadDefined("worktreeRemoved", r.worktreeRemoved),
-                        ...spreadDefined("skipReason", r.skipReason),
                         ...spreadDefined("error", r.error),
                         ...spreadDefined("detail", r.detail),
                     })),

package/dist/server/git-parity-tool.js

@@ -5,7 +5,7 @@ import { validateRepoPath } from "./inventory.js";
 import { jsonRespond, spreadDefined } from "./json.js";
 import { applyPresetParityPairs } from "./presets.js";
 import { requireGitAndRoots } from "./roots.js";
-import { WorkspacePickSchema } from "./schemas.js";
+import { RootPickSchema } from "./schemas.js";
 export function registerGitParityTool(server) {
     server.addTool({
         name: "git_parity",
@@ -13,7 +13,7 @@ export function registerGitParityTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: RootPickSchema.extend({
             pairs: z
                 .array(z.object({
                 left: z.string(),
@@ -34,17 +34,26 @@ export function registerGitParityTool(server) {
             for (const workspaceRoot of pre.roots) {
                 const top = gitTopLevel(workspaceRoot);
                 if (!top) {
-                    const errPayload = { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: workspaceRoot };
-                    const err = jsonRespond(errPayload);
+                    const errDesc = `not a git repository: ${workspaceRoot}`;
                     if (args.format === "json") {
                         results.push({
                             workspaceRoot: workspaceRoot,
                             status: "MISMATCH",
-                            pairs: [{ label: "—", leftPath: "", rightPath: "", match: false, error: err }],
+                            pairs: [{ label: "—", leftPath: "", rightPath: "", match: false, error: errDesc }],
                         });
                     }
                     else {
-                        mdParts.push(err);
+                        mdParts.push([
+                            "# Git HEAD parity",
+                            "",
+                            `status: MISMATCH`,
+                            "",
+                            `## — — error`,
+                            "```text",
+                            errDesc,
+                            "```",
+                            "",
+                        ].join("\n"));
                     }
                     continue;
                 }

package/dist/server/git-push-tool.js

@@ -16,7 +16,7 @@ export function registerGitPushTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             remote: z
                 .string()
                 .optional()
@@ -45,7 +45,9 @@ export function registerGitPushTool(server) {
             if (!branch) {
                 return jsonRespond({ error: ERROR_CODES.PUSH_DETACHED_HEAD });
             }
-            if (!isSafeGitRefToken(branch)) {
+            // Reject leading `+` (git force-update refspec) even if the shared ref
+            // token helper still permits `+` mid-name — never force-push via argv.
+            if (!isSafeGitRefToken(branch) || branch.startsWith("+")) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: branch });
             }
             // --- Resolve remote ---