@rethunk/mcp-multi-root-git 2.6.0 → 2.8.1

package/dist/server/git-cherry-pick-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { commitListBetween, conflictPaths, getCurrentBranch, isContentEquivalentlyMergedInto, isFullyMergedInto, isProtectedBranch, isSafeGitRangeToken, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -30,12 +31,12 @@ async function branchExists(gitTop, name) {
 async function resolveSource(gitTop, onto, raw) {
     if (raw.includes("..")) {
         if (!isSafeGitRangeToken(raw)) {
-            return { error: "unsafe_ref_token", raw };
+            return { error: ERROR_CODES.UNSAFE_REF_TOKEN, raw };
         }
         const r = await spawnGitAsync(gitTop, ["rev-list", "--reverse", raw]);
         if (!r.ok) {
             return {
-                error: "range_resolution_failed",
+                error: ERROR_CODES.RANGE_RESOLUTION_FAILED,
                 detail: (r.stderr || r.stdout).trim(),
                 raw,
             };
@@ -47,18 +48,18 @@ async function resolveSource(gitTop, onto, raw) {
         return { raw, kind: "range", commits };
     }
     if (!isSafeGitRefToken(raw)) {
-        return { error: "unsafe_ref_token", raw };
+        return { error: ERROR_CODES.UNSAFE_REF_TOKEN, raw };
     }
     if (await branchExists(gitTop, raw)) {
         const commits = await commitListBetween(gitTop, onto, raw);
         if (commits === null) {
-            return { error: "range_resolution_failed", raw };
+            return { error: ERROR_CODES.RANGE_RESOLUTION_FAILED, raw };
         }
         return { raw, kind: "branch", commits };
     }
     const sha = await resolveRef(gitTop, raw);
     if (!sha) {
-        return { error: "source_not_found", raw };
+        return { error: ERROR_CODES.SOURCE_NOT_FOUND, raw };
     }
     return { raw, kind: "sha", commits: [sha] };
 }
@@ -93,14 +94,11 @@ async function filterAndDedupe(gitTop, onto, resolved) {
 export function registerGitCherryPickTool(server) {
     server.addTool({
         name: "git_cherry_pick",
-        description: "Play commits from one or more sources onto a destination. Sources may be SHAs, " +
-            "`A..B` ranges, or branch names (expanded to `onto..<branch>`, oldest-first). " +
-            "Commits already reachable from the destination are skipped. Refuses on dirty tree; " +
-            "stops on the first conflict and reports paths. Optional flags auto-delete source " +
-            "branches and worktrees after success; deletion uses patch-id equivalence by default " +
-            "(content-identical commits with different SHAs are treated as merged, which is the " +
-            "normal cherry-pick outcome). Pass `strictMergedRefEquality: true` for strict `git branch -d` " +
-            "ancestry semantics. Protected branch names always skipped.",
+        description: "Cherry-pick commits from one or more sources onto a destination. Sources: SHAs, `A..B` ranges, " +
+            "or branch names (expanded to `onto..<branch>`, oldest-first). Already-reachable commits skipped. " +
+            "Refuses on dirty tree; stops on first conflict. Optional flags delete source branches/worktrees " +
+            "after success using patch-id equivalence (set `strictMergedRefEquality: true` for strict ancestry). " +
+            "Protected names always skipped.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -111,8 +109,7 @@ export function registerGitCherryPickTool(server) {
                 .array(z.string().min(1))
                 .min(1)
                 .max(50)
-                .describe("Sources to cherry-pick: SHA, `A..B` range, or branch name. Branch sources " +
-                "resolve to `onto..<branch>` (only commits missing from destination)."),
+                .describe("Sources: SHA, `A..B` range, or branch name (resolves to `onto..<branch>`)."),
             onto: z
                 .string()
                 .optional()
@@ -121,24 +118,18 @@ export function registerGitCherryPickTool(server) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("After all commits apply, delete each branch-kind source locally " +
-                "(`git branch -d`) when it is fully merged into the destination. " +
-                "Protected names always skipped; never touches remote refs."),
+                .describe("Delete branch-kind sources locally after success. Protected names and remote refs unaffected."),
             deleteMergedWorktrees: z
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("After success, remove any local worktree attached to a branch-kind source " +
-                "(`git worktree remove`). Protected tails always skipped."),
+                .describe("Remove local worktrees on branch-kind sources after success. Protected tails skipped."),
             strictMergedRefEquality: z
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("When false (default), branch deletion uses patch-id equivalence: a source branch " +
-                "is deleted when every commit it contains has a content-equivalent commit on the " +
-                "destination (same diff, different SHA — the normal cherry-pick outcome). " +
-                "Set to true to require strict ref ancestry (`git branch -d` semantics), which " +
-                "will refuse deletion after a cherry-pick because the SHA differs."),
+                .describe("false (default): delete branch when every commit is content-equivalent on destination (patch-id, normal cherry-pick outcome). " +
+                "true: require strict ref ancestry (`git branch -d` semantics — will refuse after cherry-pick due to SHA mismatch)."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -149,26 +140,26 @@ export function registerGitCherryPickTool(server) {
             const startBranch = await getCurrentBranch(gitTop);
             const onto = args.onto?.trim() || startBranch;
             if (!onto)
-                return jsonRespond({ error: "onto_detached_head" });
+                return jsonRespond({ error: ERROR_CODES.ONTO_DETACHED_HEAD });
             if (args.onto !== undefined && !isSafeGitRefToken(args.onto)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.onto });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.onto });
             }
             // --- Refuse dirty tree ---
             if (!(await isWorkingTreeClean(gitTop))) {
-                return jsonRespond({ error: "working_tree_dirty" });
+                return jsonRespond({ error: ERROR_CODES.WORKING_TREE_DIRTY });
             }
             // --- Ensure destination is checked out ---
             if (onto !== startBranch) {
                 const co = await spawnGitAsync(gitTop, ["checkout", onto]);
                 if (!co.ok) {
                     return jsonRespond({
-                        error: "checkout_failed",
+                        error: ERROR_CODES.CHECKOUT_FAILED,
                         detail: (co.stderr || co.stdout).trim(),
                     });
                 }
             }
             if (!(await resolveRef(gitTop, onto))) {
-                return jsonRespond({ error: "destination_not_found", ref: onto });
+                return jsonRespond({ error: ERROR_CODES.DESTINATION_NOT_FOUND, ref: onto });
             }
             // --- Resolve each source ---
             const resolved = [];
@@ -217,7 +208,7 @@ export function registerGitCherryPickTool(server) {
             if (allOk) {
                 for (let i = 0; i < perSourceReport.length; i++) {
                     const src = perSourceReport[i];
-                    if (!src || src.kind !== "branch")
+                    if (src?.kind !== "branch")
                         continue;
                     if (isProtectedBranch(src.raw))
                         continue;

package/dist/server/git-diff-summary-tool.js

@@ -1,5 +1,6 @@
 import { matchesGlob } from "node:path";
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
@@ -178,9 +179,8 @@ function rangeLabel(range, diffArgs) {
 export function registerGitDiffSummaryTool(server) {
     server.addTool({
         name: "git_diff_summary",
-        description: "Structured, token-efficient diff viewer. Returns per-file diffs with additions/deletions, " +
-            "truncated to configurable line limits, with noise files (lock files, dist, etc.) excluded by default. " +
-            "Use `range` to target staged, HEAD, or any revision range.",
+        description: "Structured diff viewer: per-file diffs with counts, truncated to configurable limits. " +
+            "Noise files (lock files, dist, etc.) excluded by default. Use `range` to target staged, HEAD, or a revision range.",
         annotations: {
             readOnlyHint: true,
         },
@@ -213,7 +213,7 @@ export function registerGitDiffSummaryTool(server) {
             excludePatterns: z
                 .array(z.string())
                 .optional()
-                .describe("Glob patterns to exclude. Defaults to common noise: lock files, dist, vendor, etc."),
+                .describe("Glob patterns to exclude. Default: lock files, dist, vendor, etc."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -230,7 +230,7 @@ export function registerGitDiffSummaryTool(server) {
             const statResult = await spawnGitAsync(gitTop, ["diff", "--numstat", ...diffArgs]);
             if (!statResult.ok) {
                 return jsonRespond({
-                    error: "git_diff_failed",
+                    error: ERROR_CODES.GIT_DIFF_FAILED,
                     detail: (statResult.stderr || statResult.stdout).trim(),
                 });
             }
@@ -239,7 +239,7 @@ export function registerGitDiffSummaryTool(server) {
             const diffResult = await spawnGitAsync(gitTop, ["diff", ...diffArgs]);
             if (!diffResult.ok) {
                 return jsonRespond({
-                    error: "git_diff_failed",
+                    error: ERROR_CODES.GIT_DIFF_FAILED,
                     detail: (diffResult.stderr || diffResult.stdout).trim(),
                 });
             }

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

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
 import { jsonRespond } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
@@ -19,14 +21,18 @@ function buildDiffArgs(opts) {
         const baseStr = opts.base?.trim() ?? "HEAD";
         const headStr = opts.head?.trim() ?? "HEAD";
         if (!isSafeGitUpstreamToken(baseStr) || !isSafeGitUpstreamToken(headStr)) {
-            return { ok: false, error: "unsafe_range_token" };
+            return { ok: false, error: ERROR_CODES.UNSAFE_RANGE_TOKEN };
         }
         // Use two-dot range: base..head
         args.push(`${baseStr}..${headStr}`);
     }
-    // Scope to path if provided
-    if (opts.path?.trim()) {
-        args.push("--", opts.path.trim());
+    // Apply unified context width if specified
+    if (typeof opts.unified === "number") {
+        args.push(`-U${opts.unified}`);
+    }
+    // Scope to paths if provided
+    if (opts.paths && opts.paths.length > 0) {
+        args.push("--", ...opts.paths);
     }
     return { ok: true, args };
 }
@@ -44,8 +50,8 @@ function rangeLabel(opts) {
     else {
         label = "unstaged changes";
     }
-    if (opts.path?.trim()) {
-        label += ` (${opts.path.trim()})`;
+    if (opts.paths && opts.paths.length > 0) {
+        label += ` (${opts.paths.join(", ")})`;
     }
     return label;
 }
@@ -55,9 +61,8 @@ function rangeLabel(opts) {
 export function registerGitDiffTool(server) {
     server.addTool({
         name: "git_diff",
-        description: "Get diff text for scoped file or range. Returns the raw diff output. " +
-            "Use `staged: true` for staged changes, `base`/`head` for revision ranges, " +
-            "and `path` to scope to a specific file.",
+        description: "Raw diff text for scoped file(s) or range. `staged: true` for staged changes, " +
+            "`base`/`head` for revision ranges, `path`/`paths` to scope, `unified` for context lines.",
         annotations: {
             readOnlyHint: true,
         },
@@ -68,33 +73,64 @@ export function registerGitDiffTool(server) {
             base: z
                 .string()
                 .optional()
-                .describe('Base ref (e.g. "main", "HEAD~3"). Required for range diffs. ' +
-                "If omitted and `staged: false`, shows unstaged changes."),
+                .describe('Base ref (e.g. "main", "HEAD~3"). Omit for unstaged changes.'),
             head: z
                 .string()
                 .optional()
-                .describe('Head ref (e.g. "feature-branch"). If omitted, defaults to HEAD. ' +
-                "Only used if `base` is provided."),
+                .describe('Head ref (e.g. "feature-branch"). Defaults to HEAD. Used only when `base` is set.'),
             path: z
                 .string()
                 .optional()
-                .describe('Scope diff to a single file path (e.g. "src/main.ts").'),
+                .describe("Scope to a single file. Unioned with `paths` if both given."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Scope to multiple files (must be within repo root). Unioned with `path` if both given."),
             staged: z
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("If true, show staged changes (git diff --staged). " + "Ignored if `base` is provided."),
+                .describe("Show staged changes (`git diff --staged`). Ignored if `base` is set."),
+            unified: z
+                .number()
+                .int()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe("Context lines around each change (`-U<n>`). Default: 3. Use 0 for no context."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
+            // Union path + paths, trim, dedup
+            const rawPaths = [];
+            if (args.path && typeof args.path === "string" && args.path.trim()) {
+                rawPaths.push(args.path.trim());
+            }
+            if (Array.isArray(args.paths)) {
+                for (const p of args.paths) {
+                    if (typeof p === "string" && p.trim()) {
+                        rawPaths.push(p.trim());
+                    }
+                }
+            }
+            // Dedup preserving order
+            const dedupedPaths = [...new Set(rawPaths)];
+            // Confine each path within the repo
+            for (const p of dedupedPaths) {
+                const resolved = resolvePathForRepo(p, gitTop);
+                if (!assertRelativePathUnderTop(p, resolved, gitTop)) {
+                    return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: p });
+                }
+            }
             // Build git diff args
             const diffArgsResult = buildDiffArgs({
                 base: args.base,
                 head: args.head,
-                path: args.path,
+                paths: dedupedPaths.length > 0 ? dedupedPaths : undefined,
+                unified: typeof args.unified === "number" ? args.unified : undefined,
                 staged: args.staged,
             });
             if (!diffArgsResult.ok) {
@@ -104,14 +140,14 @@ export function registerGitDiffTool(server) {
             const result = await spawnGitAsync(gitTop, diffArgsResult.args);
             if (!result.ok) {
                 return jsonRespond({
-                    error: "git_diff_failed",
+                    error: ERROR_CODES.GIT_DIFF_FAILED,
                     detail: (result.stderr || result.stdout).trim(),
                 });
             }
             const label = rangeLabel({
                 base: args.base,
                 head: args.head,
-                path: args.path,
+                paths: dedupedPaths.length > 0 ? dedupedPaths : undefined,
                 staged: args.staged,
             });
             if (args.format === "json") {

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
-import { jsonRespond } from "./json.js";
+import { jsonRespond, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
 // ---------------------------------------------------------------------------
@@ -30,6 +31,61 @@ function parseGitFetchOutput(output) {
     }
     return { updatedRefs, newRefs };
 }
+const ZEROS_SHA = "0000000000000000000000000000000000000000";
+/**
+ * Parse `git fetch --porcelain` stdout.
+ *
+ * Machine-readable lines have the form:
+ *   <flag><SP><old-sha><SP><new-sha><SP><local-ref>
+ *
+ * Flags:
+ *   ' ' = fast-forward update
+ *   '+' = forced update
+ *   '*' = new ref
+ *   '-' = pruned (deleted)
+ *   '!' = rejected
+ *   '=' = up-to-date (no change)
+ *   't' = tag update
+ */
+function parsePorcelainOutput(stdout) {
+    const updated = [];
+    const created = [];
+    const pruned = [];
+    for (const line of stdout.split("\n")) {
+        if (!line)
+            continue;
+        // Porcelain lines: flag(1) + space(1) + old-sha + space + new-sha + space + ref
+        // Minimum viable line: 1 flag + 1 space + at least some content
+        if (line.length < 3)
+            continue;
+        const flag = line[0];
+        const rest = line.slice(2); // skip "flag " prefix
+        const parts = rest.split(" ");
+        // Expected: [old-sha, new-sha, ref...]
+        if (parts.length < 3)
+            continue;
+        const oldSha = parts[0] ?? "";
+        const newSha = parts[1] ?? "";
+        const ref = parts.slice(2).join(" ");
+        if (!ref)
+            continue;
+        if (flag === "-") {
+            pruned.push({ ref });
+        }
+        else if (flag === "*" || oldSha === ZEROS_SHA) {
+            // New ref: flag is '*' OR old-sha is all-zeros
+            created.push({ ref, newSha, flag: flag ?? "*" });
+        }
+        else if (flag === " " || flag === "+" || flag === "t") {
+            // Update: old and new differ
+            if (oldSha !== newSha) {
+                updated.push({ ref, oldSha, newSha, flag: flag ?? " " });
+            }
+        }
+        // '!' (rejected) and '=' (up-to-date) are intentionally ignored
+    }
+    return { updated, created, pruned };
+}
 // ---------------------------------------------------------------------------
 // Tool registration
 // ---------------------------------------------------------------------------
@@ -80,31 +136,80 @@ export function registerGitFetchTool(server) {
             const tags = args.tags === true;
             // Validate remote and branch to prevent argument injection.
             if (!isSafeGitUpstreamToken(remote)) {
-                return jsonRespond({ error: "unsafe_remote_token", remote });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REMOTE_TOKEN, remote });
             }
             if (branch && !isSafeGitUpstreamToken(branch)) {
-                return jsonRespond({ error: "unsafe_ref_token", branch });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, branch });
             }
-            // Build git fetch command
-            const fetchArgs = ["fetch"];
+            // Build base fetch args (without --porcelain for now)
+            const baseArgs = ["fetch"];
             if (prune) {
-                fetchArgs.push("--prune");
+                baseArgs.push("--prune");
             }
             if (tags) {
-                fetchArgs.push("--tags");
+                baseArgs.push("--tags");
             }
-            fetchArgs.push(remote);
+            baseArgs.push(remote);
             if (branch) {
-                fetchArgs.push(branch);
+                baseArgs.push(branch);
+            }
+            // --- Attempt structured fetch with --porcelain (requires git >= 2.41) ---
+            let structured = null;
+            let result;
+            const porcelainArgs = ["fetch", "--porcelain"];
+            if (prune)
+                porcelainArgs.push("--prune");
+            if (tags)
+                porcelainArgs.push("--tags");
+            porcelainArgs.push(remote);
+            if (branch)
+                porcelainArgs.push(branch);
+            const porcelainResult = await spawnGitAsync(gitTop, porcelainArgs);
+            if (!porcelainResult.ok &&
+                (porcelainResult.stderr.includes("unknown option") ||
+                    porcelainResult.stderr.includes("unknown switch") ||
+                    porcelainResult.stderr.includes("invalid option"))) {
+                // --porcelain not supported: fall back to plain fetch
+                result = await spawnGitAsync(gitTop, baseArgs);
+                structured = null;
+            }
+            else {
+                // Use porcelain result (ok or actual fetch error)
+                result = porcelainResult;
+                if (porcelainResult.ok || !porcelainResult.stderr.includes("unknown option")) {
+                    structured = parsePorcelainOutput(porcelainResult.stdout);
+                }
+            }
+            // Legacy string-line parse: use combined output when porcelain is unavailable.
+            // When porcelain succeeded, derive legacy fields from structured data so
+            // that callers who rely on updatedRefs/newRefs still get useful values.
+            let updatedRefs;
+            let newRefs;
+            if (structured !== null) {
+                // Derive legacy string arrays from structured deltas
+                updatedRefs = structured.updated.map((d) => `${d.oldSha.slice(0, 7)}..${d.newSha.slice(0, 7)}  ${d.ref}`);
+                newRefs = structured.created.map((d) => `[new ref] ${d.ref} -> ${d.newSha.slice(0, 7)}`);
+            }
+            else {
+                const parsed = parseGitFetchOutput(result.stdout + result.stderr);
+                updatedRefs = parsed.updatedRefs;
+                newRefs = parsed.newRefs;
             }
-            const result = await spawnGitAsync(gitTop, fetchArgs);
-            const { updatedRefs, newRefs } = parseGitFetchOutput(result.stdout + result.stderr);
             const fetchResult = {
                 ok: result.ok,
                 remote,
                 updatedRefs,
                 newRefs,
                 output: (result.stdout + result.stderr).trim(),
+                ...spreadWhen(structured !== null && structured.updated.length > 0, {
+                    updated: structured?.updated ?? [],
+                }),
+                ...spreadWhen(structured !== null && structured.created.length > 0, {
+                    created: structured?.created ?? [],
+                }),
+                ...spreadWhen(structured !== null && structured.pruned.length > 0, {
+                    pruned: structured?.pruned ?? [],
+                }),
             };
             if (args.format === "json") {
                 return jsonRespond(fetchResult);
@@ -117,19 +222,42 @@ export function registerGitFetchTool(server) {
                 return lines.join("\n");
             }
             lines.push("", "**Status**: Success", "");
-            if (updatedRefs.length > 0) {
+            // Prefer structured deltas in markdown when available
+            if (structured !== null && structured.updated.length > 0) {
+                lines.push("## Updated refs", "");
+                for (const d of structured.updated) {
+                    lines.push(`- \`${d.ref}\` ${d.oldSha.slice(0, 7)}→${d.newSha.slice(0, 7)}`);
+                }
+            }
+            else if (updatedRefs.length > 0) {
                 lines.push("## Updated refs", "");
                 for (const ref of updatedRefs) {
                     lines.push(`- ${ref}`);
                 }
             }
-            if (newRefs.length > 0) {
+            if (structured !== null && structured.created.length > 0) {
+                lines.push("", "## New refs", "");
+                for (const d of structured.created) {
+                    lines.push(`- \`${d.ref}\` (new, ${d.newSha.slice(0, 7)})`);
+                }
+            }
+            else if (newRefs.length > 0) {
                 lines.push("", "## New refs", "");
                 for (const ref of newRefs) {
                     lines.push(`- ${ref}`);
                 }
             }
-            if (updatedRefs.length === 0 && newRefs.length === 0 && result.stdout.trim()) {
+            if (structured !== null && structured.pruned.length > 0) {
+                lines.push("", "## Pruned refs", "");
+                for (const d of structured.pruned) {
+                    lines.push(`- \`${d.ref}\` (deleted)`);
+                }
+            }
+            if (updatedRefs.length === 0 &&
+                newRefs.length === 0 &&
+                (structured === null ||
+                    (structured.updated.length === 0 && structured.created.length === 0)) &&
+                result.stdout.trim()) {
                 lines.push("", "## Output", "", "```", result.stdout.trim(), "```");
             }
             return lines.join("\n");

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitRevParseGitDir, gitTopLevel, isSafeGitUpstreamToken, } from "./git.js";
 import { buildInventorySectionMarkdown, collectInventoryEntry, makeSkipEntry, validateRepoPath, } from "./inventory.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -27,7 +28,7 @@ export function registerGitInventoryTool(server) {
         execute: async (args) => {
             if (args.absoluteGitRoots != null && args.absoluteGitRoots.length > 0) {
                 if (args.preset || (args.nestedRoots?.length ?? 0) > 0) {
-                    return jsonRespond({ error: "absolute_git_roots_nested_or_preset_conflict" });
+                    return jsonRespond({ error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_NESTED_OR_PRESET_CONFLICT });
                 }
             }
             const pre = requireGitAndRoots(server, args, args.preset);
@@ -39,12 +40,12 @@ export function registerGitInventoryTool(server) {
             const hasRemote = rawRemote !== undefined && rawRemote !== "";
             const hasBranch = rawBranch !== undefined && rawBranch !== "";
             if (hasRemote !== hasBranch) {
-                return jsonRespond({ error: "remote_branch_mismatch" });
+                return jsonRespond({ error: ERROR_CODES.REMOTE_BRANCH_MISMATCH });
             }
             let upstream = { mode: "auto" };
             if (hasRemote && hasBranch && rawRemote && rawBranch) {
                 if (!isSafeGitUpstreamToken(rawRemote) || !isSafeGitUpstreamToken(rawBranch)) {
-                    return jsonRespond({ error: "invalid_remote_or_branch" });
+                    return jsonRespond({ error: ERROR_CODES.INVALID_REMOTE_OR_BRANCH });
                 }
                 upstream = { mode: "fixed", remote: rawRemote, branch: rawBranch };
             }
@@ -54,7 +55,7 @@ export function registerGitInventoryTool(server) {
             for (const workspaceRoot of pre.roots) {
                 const top = gitTopLevel(workspaceRoot);
                 if (!top) {
-                    const err = { error: "not_a_git_repository", path: workspaceRoot };
+                    const err = { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: workspaceRoot };
                     if (args.format === "json") {
                         allJson.push({
                             workspaceRoot: workspaceRoot,