@rethunk/mcp-multi-root-git 2.4.0 → 2.5.0

package/AGENTS.md

@@ -22,7 +22,7 @@ IDEs injecting this as context: do not re-link from rules.
 | [`src/server/presets.ts`](src/server/presets.ts) | `PRESET_FILE_PATH`, `loadPresetsFromGitTop`, `presetLoadErrorPayload`, `applyPresetNestedRoots`, `applyPresetParityPairs`; Zod schemas must match [`git-mcp-presets.schema.json`](git-mcp-presets.schema.json) |
 | [`src/server/schemas.ts`](src/server/schemas.ts) | `WorkspacePickSchema`, `MAX_INVENTORY_ROOTS_DEFAULT`, **`MAX_ABSOLUTE_GIT_ROOTS`** (256), optional **`absoluteGitRoots`** on workspace pick |
 | [`src/server/inventory.ts`](src/server/inventory.ts) | `InventoryEntryJson`, `validateRepoPath`, `makeSkipEntry`, `buildInventorySectionMarkdown`, `collectInventoryEntry` |
-| [`src/server/git-refs.ts`](src/server/git-refs.ts) | `isProtectedBranch`, `isSafeGitRefToken`, `isSafeGitRangeToken`, `isSafeGitAncestorRef`; `getCurrentBranch`, `resolveRef`, `isWorkingTreeClean`, `isFullyMergedInto`, `commitListBetween`; `listWorktrees`, `worktreeForBranch`; `conflictPaths` |
+| [`src/server/git-refs.ts`](src/server/git-refs.ts) | `isProtectedBranch`, `isSafeGitRefToken`, `isSafeGitRangeToken`, `isSafeGitAncestorRef`; `getCurrentBranch`, `resolveRef`, `isWorkingTreeClean`, `isFullyMergedInto`, `isContentEquivalentlyMergedInto`, `commitListBetween`; `listWorktrees`, `worktreeForBranch`; `inferRemoteFromUpstream`; `conflictPaths` |
 | [`src/server/tools.ts`](src/server/tools.ts) | `registerRethunkGitTools` — dispatches to `register*` below |
 | [`src/server/git-status-tool.ts`](src/server/git-status-tool.ts) | `git_status` |
 | [`src/server/git-inventory-tool.ts`](src/server/git-inventory-tool.ts) | `git_inventory` |

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to `@rethunk/mcp-multi-root-git` are documented here. Format
 
 ## [Unreleased]
 
+## [2.5.0] — 2026-05-15
+
+Bug-fix and documentation release; includes one new `git_log` output format.
+
+### Added
+
+- **`git_log` `format: "oneline"`** — minimal `<sha7> <subject>` output per commit for low-token post-commit verification. Multi-root output uses `### repo (branch)` separators; single-root output emits one line per commit with no headers.
+
+### Fixed
+
+- **`git_stash_list`**: format string used for-each-ref placeholders (`%(subject)`, `%(objectname:short)`) instead of git-log format (`%s`, `%h`), printing literal placeholder text as the stash message.
+- **`git_stash_list`**: stash message containing `|` caused the SHA field to be parsed as a mid-message fragment; SHA is now always the last pipe-separated field.
+- **`batch_commit`**: deleted tracked files (missing on disk) could not be staged; now staged via `git rm --cached`. Combining `{ path, lines }` with a deleted file is validated as an error.
+- **`batch_commit` hunk-level staging**: `newCount=0` pure-deletion hunks were excluded from line ranges that included the deletion point (`hunkEnd` was `newStart-1`); now `hunkEnd = newStart` for zero-count hunks.
+- **`git_diff_summary`**: diff header regex mis-parsed file paths containing ` b/` (e.g. `src/b/file.ts`), reporting wrong path and zero stats; now uses midpoint-symmetry split for non-renames, falls back to regex for renames.
+- **`git_diff_summary`**: `git diff --stat` bar-graph character counting is scaled to terminal width and under-reports for large files; replaced with `git diff --numstat` for exact addition/deletion counts.
+- **`git_cherry_pick`**: branch deletion after cherry-pick now uses patch-id equivalence by default so source branches with differing SHAs but identical content are correctly detected as merged. Pass `strictMergedRefEquality: true` for strict SHA-reachability semantics.
+- **`parseGitSubmodulePaths`**: non-regular files at `.gitmodules` (character devices, sockets — common in Claude Code / sandbox environments) are now rejected via `lstatSync().isFile()` before `readFileSync`, preventing `EACCES` errors.
+
+### Tests
+
+- Integration tests added for `git_stash_list`, `git_stash_apply`, `git_fetch`, `git_status`, `git_inventory`, and `git_parity` execute paths.
+- `isContentEquivalentlyMergedInto` integration tests via real git repos with cherry-picked and diverged histories.
+- `batch_commit` dryRun tests covering deleted-file unstaging.
+
+### Documentation
+
+- **`git_status`, `git_inventory`, `git_parity`, `list_presets`** now have complete parameter tables, JSON shape examples, and error code tables in `docs/mcp-tools.md`.
+- **`git_cherry_pick`** `strictMergedRefEquality` parameter added to docs; `deleteMergedBranches` description corrected (default is patch-id equivalence, not SHA-reachability).
+- **`batch_commit`** `files` parameter and `stage_failed` error code updated to document deleted-file staging path.
+
 ## [2.4.0] — 2026-05-07
 
 New git MCP tools, better `batch_commit` ergonomics, published schema coverage for the full tool surface, and a broad docs/test refresh since `v2.3.4`.

package/dist/server/batch-commit-tool.js

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { z } from "zod";
 import { isStrictlyUnderGitTop, resolvePathForRepo } from "../repo-paths.js";
 import { spawnGitAsync } from "./git.js";
@@ -22,7 +23,9 @@ const CommitEntrySchema = z.object({
     files: z
         .array(FileEntrySchema)
         .min(1)
-        .describe("Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging."),
+        .describe("Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging. " +
+        "Deleted files (missing on disk but tracked in HEAD) are staged as removals via `git rm --cached`. " +
+        "Combining { path, lines } with a deleted file is an error."),
 });
 const PushModeSchema = z
     .enum(["never", "after"])
@@ -74,7 +77,9 @@ function extractOverlappingHunks(diffContent, fromLine, toLine) {
         if (hunkMatch) {
             const newStart = Number.parseInt(hunkMatch[1] || "0", 10);
             const newCount = Number.parseInt(hunkMatch[2] || "1", 10);
-            const hunkEnd = newStart + newCount - 1;
+            // newCount=0 means pure deletion; hunkEnd must equal newStart so ranges
+            // that include newStart correctly capture the deletion.
+            const hunkEnd = newCount === 0 ? newStart : newStart + newCount - 1;
             // Check if hunk overlaps with requested line range
             const hasOverlap = !(hunkEnd < fromLine || newStart > toLine);
             if (hasOverlap) {
@@ -123,6 +128,23 @@ function extractOverlappingHunks(diffContent, fromLine, toLine) {
  * overlapping the range are staged via a partial patch. Otherwise, stages the whole file.
  */
 async function stageFile(gitTop, filePath, lines) {
+    const absPath = resolvePathForRepo(filePath, gitTop);
+    const fileOnDisk = existsSync(absPath);
+    if (!fileOnDisk) {
+        if (lines) {
+            return { ok: false, error: "cannot stage line range for deleted file" };
+        }
+        // File missing on disk — stage as removal if tracked in HEAD
+        const lsResult = await spawnGitAsync(gitTop, ["ls-files", "--error-unmatch", "--", filePath]);
+        if (!lsResult.ok) {
+            return { ok: false, error: `pathspec '${filePath}' did not match any files` };
+        }
+        const rmResult = await spawnGitAsync(gitTop, ["rm", "--cached", "--", filePath]);
+        return {
+            ok: rmResult.ok,
+            error: rmResult.ok ? undefined : (rmResult.stderr || rmResult.stdout).trim(),
+        };
+    }
     if (!lines) {
         // Simple case: stage the whole file
         const addResult = await spawnGitAsync(gitTop, ["add", "--", filePath]);

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { spawnGitAsync } from "./git.js";
-import { commitListBetween, conflictPaths, getCurrentBranch, isFullyMergedInto, isProtectedBranch, isSafeGitRangeToken, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
+import { commitListBetween, conflictPaths, getCurrentBranch, isContentEquivalentlyMergedInto, isFullyMergedInto, isProtectedBranch, isSafeGitRangeToken, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -96,8 +96,11 @@ export function registerGitCherryPickTool(server) {
         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 fully " +
-            "merged source branches and their worktrees, skipping protected names.",
+            "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.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -127,6 +130,15 @@ export function registerGitCherryPickTool(server) {
                 .default(false)
                 .describe("After success, remove any local worktree attached to a branch-kind source " +
                 "(`git worktree remove`). Protected tails always 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."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -221,11 +233,23 @@ export function registerGitCherryPickTool(server) {
                         }
                     }
                     if (args.deleteMergedBranches) {
-                        const merged = await isFullyMergedInto(gitTop, src.raw, onto);
-                        if (merged) {
-                            const r = await spawnGitAsync(gitTop, ["branch", "-d", src.raw]);
-                            if (r.ok)
-                                src.branchDeleted = true;
+                        if (args.strictMergedRefEquality) {
+                            const merged = await isFullyMergedInto(gitTop, src.raw, onto);
+                            if (merged) {
+                                const r = await spawnGitAsync(gitTop, ["branch", "-d", src.raw]);
+                                if (r.ok)
+                                    src.branchDeleted = true;
+                            }
+                        }
+                        else {
+                            const merged = await isContentEquivalentlyMergedInto(gitTop, src.raw, onto);
+                            if (merged) {
+                                // -D required: git branch -d checks ref ancestry (fails after cherry-pick),
+                                // but we've already verified content equivalence via patch-id.
+                                const r = await spawnGitAsync(gitTop, ["branch", "-D", src.raw]);
+                                if (r.ok)
+                                    src.branchDeleted = true;
+                            }
                         }
                     }
                 }

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

@@ -24,23 +24,25 @@ const DEFAULT_EXCLUDE_PATTERNS = [
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * Parse `git diff --stat` output into per-file stats.
- * Format: " path/to/file | N ++++---"
- * Final line: " N files changed, N insertions(+), N deletions(-)"
+ * Parse `git diff --numstat` output into exact per-file counts.
+ * Format per line: "<additions>\t<deletions>\t<path>"
+ * Binary files emit "-\t-\t<path>" and are recorded as 0/0.
  */
-function parseStatOutput(stat) {
+function parseNumstatOutput(numstat) {
     const result = new Map();
-    for (const line of stat.split("\n")) {
-        // Skip the summary line and blank lines
-        if (!line.includes("|"))
+    for (const line of numstat.split("\n")) {
+        const parts = line.split("\t");
+        if (parts.length < 3)
             continue;
-        const pipeIdx = line.indexOf("|");
-        const filePart = line.slice(0, pipeIdx).trim();
-        const statPart = line.slice(pipeIdx + 1).trim();
-        // statPart looks like "5 ++---" or "3 +++", count + and -
-        const additions = (statPart.match(/\+/g) ?? []).length;
-        const deletions = (statPart.match(/-/g) ?? []).length;
-        result.set(filePart, { additions, deletions });
+        const [addStr, delStr, ...pathParts] = parts;
+        const filePath = pathParts.join("\t");
+        if (!filePath)
+            continue;
+        const additions = addStr === "-" ? 0 : Number.parseInt(addStr ?? "0", 10);
+        const deletions = delStr === "-" ? 0 : Number.parseInt(delStr ?? "0", 10);
+        if (!Number.isNaN(additions) && !Number.isNaN(deletions)) {
+            result.set(filePath, { additions, deletions });
+        }
     }
     return result;
 }
@@ -68,10 +70,26 @@ function parseDiffOutput(diff) {
  * Body may contain "rename from", "rename to", "new file mode", "deleted file mode".
  */
 function extractFileInfo(header, body) {
-    // Parse "diff --git a/X b/Y"
-    const headerMatch = /^diff --git a\/(.+) b\/(.+)$/.exec(header);
-    const aPath = headerMatch?.[1] ?? "";
-    const bPath = headerMatch?.[2] ?? aPath;
+    // Parse "diff --git a/X b/Y". For non-renames X === Y; use midpoint split so
+    // paths containing " b/" (e.g. "src/b/file.ts") are not mis-parsed by a greedy regex.
+    const prefix = "diff --git a/";
+    const raw = header.startsWith(prefix) ? header.slice(prefix.length) : "";
+    const midLen = (raw.length - " b/".length) / 2;
+    let aPath = "";
+    let bPath = "";
+    if (Number.isInteger(midLen) && midLen > 0) {
+        const candidate = raw.slice(0, midLen);
+        if (raw.slice(midLen) === ` b/${candidate}`) {
+            aPath = candidate;
+            bPath = candidate;
+        }
+    }
+    if (!aPath) {
+        // Fall back for renames (aPath ≠ bPath); rename paths also come from body lines.
+        const headerMatch = /^diff --git a\/(.+) b\/(.+)$/.exec(header);
+        aPath = headerMatch?.[1] ?? "";
+        bPath = headerMatch?.[2] ?? aPath;
+    }
     let status = "modified";
     let oldPath;
     if (/^new file mode/m.test(body)) {
@@ -202,15 +220,15 @@ export function registerGitDiffSummaryTool(server) {
                 return jsonRespond({ error: diffArgsResult.error });
             }
             const diffArgs = diffArgsResult.args;
-            // --- Run git diff --stat ---
-            const statResult = await spawnGitAsync(gitTop, ["diff", "--stat", ...diffArgs]);
+            // --- Run git diff --numstat for exact addition/deletion counts ---
+            const statResult = await spawnGitAsync(gitTop, ["diff", "--numstat", ...diffArgs]);
             if (!statResult.ok) {
                 return jsonRespond({
                     error: "git_diff_failed",
                     detail: (statResult.stderr || statResult.stdout).trim(),
                 });
             }
-            const statMap = parseStatOutput(statResult.stdout);
+            const statMap = parseNumstatOutput(statResult.stdout);
             // --- Run git diff ---
             const diffResult = await spawnGitAsync(gitTop, ["diff", ...diffArgs]);
             if (!diffResult.ok) {

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

@@ -133,6 +133,22 @@ async function runGitLog(opts) {
 // ---------------------------------------------------------------------------
 // Markdown rendering
 // ---------------------------------------------------------------------------
+function renderLogOneline(group, multiRoot) {
+    const lines = [];
+    if (multiRoot) {
+        lines.push(`### ${group.repo} (${group.branch})`);
+    }
+    for (const c of group.commits) {
+        lines.push(`${c.sha.slice(0, 7)} ${c.subject}`);
+    }
+    if (group.commits.length === 0) {
+        lines.push("(no commits)");
+    }
+    if (group.truncated) {
+        lines.push(`(+${group.omittedCount} more)`);
+    }
+    return lines.join("\n");
+}
 function renderLogMarkdown(group, filterSummary) {
     const lines = [];
     lines.push(`### ${group.repo} (${group.branch})${filterSummary ? `  —  ${filterSummary}` : ""}`);
@@ -164,6 +180,13 @@ export function registerGitLogTool(server) {
             readOnlyHint: true,
         },
         parameters: WorkspacePickSchema.extend({
+            format: z
+                .enum(["markdown", "json", "oneline"])
+                .optional()
+                .default("markdown")
+                .describe("`markdown` (default): headed sections per root. " +
+                "`json`: structured groups array. " +
+                "`oneline`: `<sha7> <subject>` per line, no headers (single-root) or `### repo (branch)` separator per group (multi-root). Lowest-token option for post-commit verification."),
             since: z
                 .string()
                 .optional()
@@ -258,6 +281,20 @@ export function registerGitLogTool(server) {
                 });
                 return jsonRespond({ groups });
             }
+            // Oneline
+            if (args.format === "oneline") {
+                const multiRoot = results.length > 1;
+                const chunks = [];
+                for (const r of results) {
+                    if (r._error) {
+                        chunks.push(multiRoot ? `### ${r.workspaceRoot}\n(error: ${r.error})` : `(error: ${r.error})`);
+                        continue;
+                    }
+                    const { _error: _e, ...group } = r;
+                    chunks.push(renderLogOneline(group, multiRoot));
+                }
+                return chunks.join("\n\n");
+            }
             // Markdown
             const mdChunks = ["# Git log"];
             for (const r of results) {

package/dist/server/git-refs.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { spawnGitAsync } from "./git.js";
 // ---------------------------------------------------------------------------
 // Merge conflict helpers (shared between git_merge and git_cherry_pick)
@@ -124,6 +125,77 @@ export async function isFullyMergedInto(cwd, branch, target) {
     const r = await spawnGitAsync(cwd, ["merge-base", "--is-ancestor", branch, target]);
     return r.ok;
 }
+/**
+ * Returns the git patch-id for a single commit, or undefined on failure.
+ * Uses execFileSync to pipe `git diff-tree --patch -r <sha>` into `git patch-id --stable`.
+ */
+function commitPatchId(cwd, sha) {
+    try {
+        const diff = execFileSync("git", ["diff-tree", "--patch", "-r", sha], {
+            cwd,
+            encoding: "utf8",
+        });
+        const out = execFileSync("git", ["patch-id", "--stable"], {
+            cwd,
+            encoding: "utf8",
+            input: diff,
+        });
+        return out.trim().split(" ")[0] || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Returns true when every commit reachable from `branch` but not from `target` has a
+ * patch-equivalent commit already in `target` (content-equivalent merge check for
+ * cherry-pick workflows where SHA differs but diff is identical).
+ *
+ * Falls back to ref-equality (`isFullyMergedInto`) when patch-id comparison fails.
+ */
+export async function isContentEquivalentlyMergedInto(cwd, branch, target) {
+    if (!isSafeGitRefToken(branch) || !isSafeGitRefToken(target))
+        return false;
+    // Fast path: ref equality (normal merge).
+    const refMerged = await spawnGitAsync(cwd, ["merge-base", "--is-ancestor", branch, target]);
+    if (refMerged.ok)
+        return true;
+    // Collect commits in branch not reachable from target.
+    const srcList = await spawnGitAsync(cwd, ["rev-list", "--no-merges", `${branch}`, `^${target}`]);
+    if (!srcList.ok)
+        return false;
+    const srcShas = srcList.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    if (srcShas.length === 0)
+        return true; // nothing to check
+    // Build patch-id set for target commits since merge-base.
+    const base = await spawnGitAsync(cwd, ["merge-base", branch, target]);
+    if (!base.ok)
+        return false;
+    const baseSha = base.stdout.trim();
+    const destList = await spawnGitAsync(cwd, ["rev-list", "--no-merges", `${baseSha}..${target}`]);
+    if (!destList.ok)
+        return false;
+    const destShas = destList.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    const destPatchIds = new Set();
+    for (const sha of destShas) {
+        const patchId = commitPatchId(cwd, sha);
+        if (patchId)
+            destPatchIds.add(patchId);
+    }
+    // Every source commit must have its patch-id present in destination.
+    for (const sha of srcShas) {
+        const patchId = commitPatchId(cwd, sha);
+        if (!patchId || !destPatchIds.has(patchId))
+            return false;
+    }
+    return true;
+}
 /**
  * SHAs of commits in `exclude..include`, oldest-first (cherry-pick feed order).
  * Returns `null` on git failure.

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

@@ -12,7 +12,7 @@ import { WorkspacePickSchema } from "./schemas.js";
  */
 async function runGitShow(opts) {
     const { top, ref, path } = opts;
-    // Build git show args. Start with --no-patch to get just the commit message.
+    // Build git show args. Shows commit message + full diff (or file content when path given).
     const showArgs = ["show", ref];
     if (path) {
         // When path is specified, show that path at the ref without --no-patch

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

@@ -24,11 +24,8 @@ export function registerGitStashListTool(server) {
                 return jsonRespond(pre.error);
             const { gitTop } = pre;
             // List all stashes: git stash list --format='%(refname:short)|%(subject)|%(objectname:short)'
-            const r = await spawnGitAsync(gitTop, [
-                "stash",
-                "list",
-                "--format=%(refname:short)|%(subject)|%(objectname:short)",
-            ]);
+            // git stash list uses git-log format (%s, %h) not for-each-ref format %(subject).
+            const r = await spawnGitAsync(gitTop, ["stash", "list", "--format=%gd|%s|%h"]);
             if (!r.ok) {
                 // If there are no stashes, git still returns ok=true with empty output
                 // Only treat as error if git itself failed
@@ -46,11 +43,14 @@ export function registerGitStashListTool(server) {
                 const line = lines[i];
                 if (line) {
                     const parts = line.split("|");
-                    if (parts.length >= 3 && parts[1] && parts[2]) {
+                    // parts[0] = stash@{N}, last part = short SHA, middle = message (may contain "|")
+                    const sha = parts[parts.length - 1];
+                    const message = parts.slice(1, -1).join("|");
+                    if (parts.length >= 3 && message && sha) {
                         stashes.push({
                             index: i,
-                            message: parts[1],
-                            sha: parts[2],
+                            message,
+                            sha,
                         });
                     }
                 }

package/dist/server/git.js

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { cpus } from "node:os";
 import { join } from "node:path";
 /**
@@ -77,7 +77,22 @@ export function parseGitSubmodulePaths(gitRoot) {
     const f = join(gitRoot, ".gitmodules");
     if (!existsSync(f))
         return [];
-    const text = readFileSync(f, "utf8");
+    // Skip non-regular files (character devices, sockets, etc.) — common in
+    // Claude Code sandbox environments where stub device files shadow paths.
+    try {
+        if (!lstatSync(f).isFile())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    let text;
+    try {
+        text = readFileSync(f, "utf8");
+    }
+    catch {
+        return [];
+    }
     const paths = [];
     for (const line of text.split("\n")) {
         const m = /^\s*path\s*=\s*(.+)\s*$/.exec(line);

package/docs/mcp-tools.md

@@ -15,7 +15,7 @@ MCP clients expose tools as `{serverName}_{toolName}`. With the server registere
 | `git_inventory` | `rethunk-git_git_inventory` | Status + ahead/behind per path; default upstream each repo’s `@{u}`; pass **both** `remote` and `branch` for fixed tracking. `nestedRoots`, `preset`, `presetMerge`, `maxRoots`, `format`, plus workspace pick args (`absoluteGitRoots` cannot combine with `preset`/`nestedRoots`). **Read-only.** |
 | `git_parity` | `rethunk-git_git_parity` | Compare `git rev-parse HEAD` for path pairs. `pairs`, `preset`, `presetMerge`, `format`, plus workspace pick args (`absoluteGitRoots` for sibling clone batches). **Read-only.** |
 | `list_presets` | `rethunk-git_list_presets` | List preset names/counts from `.rethunk/git-mcp-presets.json`; invalid JSON/schema surface as errors. Workspace pick + `format` only (includes `absoluteGitRoots`). **Read-only.** |
-| `git_log` | `rethunk-git_git_log` | Path-filtered, time-windowed `git log` across one or more workspace roots. Returns commit history with author, date, subject, and shortstat. Args: `since`, `paths`, `grep`, `author`, `maxCommits`, `branch`, plus workspace pick args (`absoluteGitRoots` for sibling clones) + `format`. **Read-only.** |
+| `git_log` | `rethunk-git_git_log` | Path-filtered, time-windowed `git log` across one or more workspace roots. Returns commit history with author, date, subject, and shortstat. Args: `since`, `paths`, `grep`, `author`, `maxCommits`, `branch`, plus workspace pick args (`absoluteGitRoots` for sibling clones) + `format` (`markdown`/`json`/`oneline`). **Read-only.** |
 | `git_diff_summary` | `rethunk-git_git_diff_summary` | Structured, token-efficient diff viewer. Returns per-file diffs with additions/deletions counts, truncated to configurable line limits, with lock files/dist/vendor excluded by default. Args: `range`, `fileFilter`, `maxLinesPerFile`, `maxFiles`, `excludePatterns`, plus workspace pick args (optional single-entry `absoluteGitRoots`) + `format`. **Read-only.** |
 | `git_diff` | `rethunk-git_git_diff` | Raw diff text for a single repo. Supports unstaged, staged, or `base..head` ranges, optionally scoped to one path. Args: `base?`, `head?`, `path?`, `staged?`, plus single-repo workspace pick + `format`. **Read-only.** |
 | `git_show` | `rethunk-git_git_show` | Inspect one commit or ref. Returns commit message plus diff, or file content at `path` for that ref. Args: `ref`, `path?`, plus single-repo workspace pick + `format`. **Read-only.** |
@@ -29,11 +29,234 @@ MCP clients expose tools as `{serverName}_{toolName}`. With the server registere
 | `git_reset_soft` | `rethunk-git_git_reset_soft` | Soft-reset the current branch to a ref (`HEAD~N`, SHA, branch). Rewound changes land in the staging index; requires a clean working tree. Args: `ref`, plus workspace pick + `format`. **Mutating — not idempotent.** |
 | `batch_commit` | `rethunk-git_batch_commit` | Create multiple sequential git commits in a single call. Each entry stages the listed files or line-ranged file hunks, then commits with the given message. Stops on first failure. Optional `push: "after"` pushes once every commit lands; optional `dryRun: true` previews staged content without writing commits. Args: `commits` (array of `{message, files}`), `push?`, `dryRun?`, plus workspace pick args + `format`. **Mutating — not idempotent.** |
 | `git_merge` | `rethunk-git_git_merge` | Merge one or more source branches into a destination. Default strategy `auto` cascades fast-forward → rebase → merge-commit per source, preferring linear history. Refuses on dirty tree; stops on first conflict with structured path report. Optional `deleteMergedBranches` / `deleteMergedWorktrees` cascade cleanup, always skipping protected names (main/master/dev/develop/stable/trunk/prod/production/release\*/hotfix\*). Args: `sources`, `into?`, `strategy?`, `message?`, cleanup flags + workspace pick + `format`. **Mutating.** |
-| `git_cherry_pick` | `rethunk-git_git_cherry_pick` | 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). Uses `--empty=drop` so patch-equivalent re-applies add nothing. Refuses on dirty tree; stops on first conflict, aborting cleanly. Same cleanup flags as `git_merge` (branch-kind sources only, protected names skipped). Args: `sources`, `onto?`, cleanup flags + workspace pick + `format`. **Mutating.** |
+| `git_cherry_pick` | `rethunk-git_git_cherry_pick` | 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). Uses `--empty=drop` so patch-equivalent re-applies add nothing. Refuses on dirty tree; stops on first conflict, aborting cleanly. Same cleanup flags as `git_merge` (branch-kind sources only, protected names skipped); branch deletion uses patch-id equivalence by default so cherry-pick workflows (where SHA differs but diff is identical) clean up correctly. Pass `strictMergedRefEquality: true` for strict `git branch -d` ancestry semantics. Args: `sources`, `onto?`, cleanup flags, `strictMergedRefEquality?` + workspace pick + `format`. **Mutating.** |
 | `git_stash_apply` | `rethunk-git_git_stash_apply` | Apply or pop a stash entry for one repo. Args: `index?`, `pop?`, plus single-repo workspace pick + `format`. **Mutating.** |
 
 Pass **`format: "json"`** on any tool for structured JSON instead of markdown (default).
 
+---
+
+### `git_status` — parameters
+
+| Parameter | Type | Default | Notes |
+|-----------|------|---------|-------|
+| `includeSubmodules` | boolean | `true` | When `true`, reads `.gitmodules` at each git toplevel and runs `git status --short -b` for each checked-out submodule in parallel. Set `false` to skip submodule discovery entirely. |
+| `workspaceRoot` | string | — | Explicit root; highest priority. |
+| `rootIndex` | int | — | Pick one of several MCP roots (0-based). |
+| `allWorkspaceRoots` | boolean | `false` | Fan out across all MCP roots. |
+| `absoluteGitRoots` | string[] | — | Explicit list of absolute paths; replaces normal workspace pick. Max 256. Read-only tools only. |
+| `format` | `"markdown"` \| `"json"` | `"markdown"` | Output format. |
+
+### `git_status` — JSON shape (`format: "json"`)
+
+```json
+{
+  "groups": [{
+    "mcpRoot": "/abs/workspace",
+    "repos": [
+      { "label": ".", "path": "/abs/workspace", "statusText": "## main...origin/main\nM src/foo.ts", "ok": true },
+      { "label": "sub", "path": "/abs/workspace/sub", "statusText": "## main...origin/main", "ok": true }
+    ]
+  }]
+}
+```
+
+One `groups` entry per resolved root. Each `repos` entry has `label` (relative path, `"."` for the root), `path` (absolute), `statusText` (full `git status --short -b` output), and `ok` (`false` when git failed or the submodule is not checked out).
+
+### `git_status` — error codes
+
+Error payloads appear as top-level JSON or inline in individual repo rows (`ok: false`):
+
+| Code / statusText | Context | Meaning |
+|-------------------|---------|---------|
+| `git_not_found` | top-level | `git` binary not on `PATH`. |
+| `not_a_git_repository` | repo row `statusText` | Root is not inside a git repository. |
+| `(submodule path escapes repository — rejected)` | repo row `statusText` | `.gitmodules` path resolves outside the git toplevel (security guard). |
+| `(no .git — submodule not checked out?)` | repo row `statusText` | Submodule directory exists but has no `.git` — not initialized. |
+| `root_index_out_of_range` | top-level | `rootIndex` exceeds the number of MCP file roots. |
+| `absolute_git_roots_exclusive` | top-level | `absoluteGitRoots` combined with `workspaceRoot`, `rootIndex`, or `allWorkspaceRoots: true`. |
+| `invalid_absolute_git_root` | top-level | An `absoluteGitRoots` entry is not a git-recognized directory. |
+| `absolute_git_roots_too_many` | top-level | More than 256 entries in `absoluteGitRoots`. |
+| `absolute_git_roots_empty` | top-level | `absoluteGitRoots` resolved to zero toplevels. |
+
+---
+
+### `git_inventory` — parameters
+
+| Parameter | Type | Default | Notes |
+|-----------|------|---------|-------|
+| `nestedRoots` | string[] | — | Relative paths (from the workspace git toplevel) to treat as independent git repos to inventory. Each must be a valid git work tree; invalid paths produce skip entries rather than errors. Cannot combine with `absoluteGitRoots` or `preset`. |
+| `preset` | string | — | Preset name from `.rethunk/git-mcp-presets.json`. Loads `nestedRoots` from the preset's entry. Cannot combine with `absoluteGitRoots`. |
+| `presetMerge` | boolean | `false` | When `true`, merge inline `nestedRoots` with preset roots instead of replacing. |
+| `remote` | string | — | Fixed remote for ahead/behind tracking. Must be paired with `branch`. |
+| `branch` | string | — | Fixed branch for ahead/behind tracking. Must be paired with `remote`. When both are absent the tool uses each repo's `@{u}` upstream. |
+| `maxRoots` | int | `64` | Max nested roots to process (1–256). Roots beyond the limit are omitted; `nestedRootsTruncated: true` and `nestedRootsOmittedCount` are set on the group. |
+| `workspaceRoot` | string | — | Explicit root; highest priority. |
+| `rootIndex` | int | — | Pick one of several MCP roots (0-based). |
+| `allWorkspaceRoots` | boolean | `false` | Fan out across all MCP roots. |
+| `absoluteGitRoots` | string[] | — | Explicit list; replaces normal workspace pick. Cannot combine with `nestedRoots` or `preset`. |
+| `format` | `"markdown"` \| `"json"` | `"markdown"` | Output format. |
+
+### `git_inventory` — JSON shape (`format: "json"`)
+
+```json
+{
+  "inventories": [{
+    "workspace_root": "/abs/path",
+    "entries": [{
+      "label": ".",
+      "path": "/abs/path",
+      "upstreamMode": "auto",
+      "branchStatus": "## main...origin/main",
+      "headAbbrev": "a1b2c3d",
+      "upstreamRef": "origin/main",
+      "ahead": "2",
+      "behind": "0"
+    }],
+    "nestedRootsTruncated": true,
+    "nestedRootsOmittedCount": 3,
+    "upstream": { "mode": "fixed", "remote": "origin", "branch": "main" }
+  }]
+}
+```
+
+`nestedRootsTruncated` / `nestedRootsOmittedCount` present only when `maxRoots` cut the list. `upstream` object present only when `remote`+`branch` were supplied (fixed mode). `presetSchemaVersion` present only when a preset was loaded. See *v2/v3 field omission* for `entries[*]` optional fields.
+
+### `git_inventory` — error codes
+
+| Code | Meaning |
+|------|---------|
+| `git_not_found` | `git` binary not on `PATH`. |
+| `remote_branch_mismatch` | Only one of `remote` / `branch` was provided; supply both or neither. |
+| `invalid_remote_or_branch` | `remote` or `branch` contains characters outside the safe token set. |
+| `absolute_git_roots_nested_or_preset_conflict` | `absoluteGitRoots` combined with `nestedRoots` or `preset`. |
+| `absolute_git_roots_exclusive` | `absoluteGitRoots` combined with `workspaceRoot`, `rootIndex`, or `allWorkspaceRoots: true`. |
+| `absolute_git_roots_preset_conflict` | `absoluteGitRoots` combined with a `preset` argument. |
+| `invalid_absolute_git_root` | An `absoluteGitRoots` entry is not a git-recognized directory. |
+| `absolute_git_roots_too_many` | More than 256 entries in `absoluteGitRoots`. |
+| `absolute_git_roots_empty` | `absoluteGitRoots` resolved to zero toplevels. |
+| `root_index_out_of_range` | `rootIndex` exceeds the number of MCP file roots. |
+| `preset_not_found` | Named preset does not exist in the preset file. |
+| `invalid_json` | Preset file contains invalid JSON. |
+| `invalid_schema` | Preset file fails schema validation. |
+
+Skip entries (individual repos that could not be inventoried) appear inline in `entries[*]` with `skipReason` rather than as top-level errors.
+
+---
+
+### `git_parity` — parameters
+
+| Parameter | Type | Notes |
+|-----------|------|-------|
+| `pairs` | `{left: string, right: string, label?: string}[]` | Path pairs to compare. `left` and `right` are relative to the workspace git toplevel. `label` is optional display name; defaults to `"left / right"`. At least one pair required (via inline `pairs` or `preset`). |
+| `preset` | string | Preset name from `.rethunk/git-mcp-presets.json`. Loads `parityPairs` from the preset's entry. |
+| `presetMerge` | boolean | Default `false`. When `true`, merge inline `pairs` with preset pairs instead of replacing. |
+| `workspaceRoot` | string | Explicit root; highest priority. |
+| `rootIndex` | int | Pick one of several MCP roots (0-based). |
+| `allWorkspaceRoots` | boolean | `false` | Fan out across all MCP roots. |
+| `absoluteGitRoots` | string[] | Explicit list of absolute paths; replaces normal workspace pick. Useful for checking parity across sibling clones. |
+| `format` | `"markdown"` \| `"json"` | Output format. Default: `"markdown"`. |
+
+### `git_parity` — JSON shape (`format: "json"`)
+
+```json
+{
+  "parity": [{
+    "workspace_root": "/abs/path",
+    "status": "MISMATCH",
+    "pairs": [
+      {
+        "label": "shared",
+        "leftPath": "/abs/path/left",
+        "rightPath": "/abs/path/right",
+        "match": true,
+        "sha": "a1b2c3d4e5f6…"
+      },
+      {
+        "label": "config",
+        "leftPath": "/abs/path/cfg-a",
+        "rightPath": "/abs/path/cfg-b",
+        "match": false,
+        "leftSha": "a1b2c3d…",
+        "rightSha": "f9e8d7c…"
+      }
+    ]
+  }]
+}
+```
+
+`status` is `"OK"` when every pair matches, `"MISMATCH"` when any pair differs or errors. On a match, `sha` carries the common HEAD SHA. On a mismatch, `leftSha` / `rightSha` carry the differing SHAs. On error (path escape or `git rev-parse HEAD` failure), `error` carries a description string and both SHA fields are absent. `presetSchemaVersion` is present when a preset was loaded.
+
+### `git_parity` — error codes
+
+| Code | Meaning |
+|------|---------|
+| `git_not_found` | `git` binary not on `PATH`. |
+| `no_pairs` | Neither inline `pairs` nor a preset with `parityPairs` was supplied. |
+| `absolute_git_roots_exclusive` | `absoluteGitRoots` combined with `workspaceRoot`, `rootIndex`, or `allWorkspaceRoots: true`. |
+| `absolute_git_roots_preset_conflict` | `absoluteGitRoots` combined with a `preset` argument. |
+| `invalid_absolute_git_root` | An `absoluteGitRoots` entry is not a git-recognized directory. |
+| `absolute_git_roots_too_many` | More than 256 entries in `absoluteGitRoots`. |
+| `absolute_git_roots_empty` | `absoluteGitRoots` resolved to zero toplevels. |
+| `root_index_out_of_range` | `rootIndex` exceeds the number of MCP file roots. |
+| `preset_not_found` | Named preset does not exist in the preset file. |
+| `invalid_json` | Preset file contains invalid JSON. |
+| `invalid_schema` | Preset file fails schema validation. |
+
+Path-escape and `rev-parse` failures are reported inline in `pairs[*].error`, not as top-level error codes.
+
+---
+
+### `list_presets` — parameters
+
+| Parameter | Type | Notes |
+|-----------|------|-------|
+| `workspaceRoot` | string | Explicit root; highest priority. |
+| `rootIndex` | int | Pick one of several MCP roots (0-based). |
+| `allWorkspaceRoots` | boolean | Default `false`. Fan out across all MCP roots. |
+| `absoluteGitRoots` | string[] | Explicit list; replaces normal workspace pick. |
+| `format` | `"markdown"` \| `"json"` | Output format. Default: `"markdown"`. |
+
+### `list_presets` — JSON shape (`format: "json"`)
+
+```json
+{
+  "roots": [{
+    "workspaceRoot": "/abs/workspace",
+    "gitTop": "/abs/workspace",
+    "presetFile": "/abs/workspace/.rethunk/git-mcp-presets.json",
+    "fileExists": true,
+    "presetSchemaVersion": "1",
+    "presets": [
+      {
+        "name": "monorepo",
+        "nestedRootsCount": 5,
+        "parityPairsCount": 2,
+        "workspaceRootHint": "/abs/workspace"
+      }
+    ]
+  }]
+}
+```
+
+`gitTop` is `null` when the workspace root is not inside a git repository. `presetSchemaVersion` is omitted when absent. `workspaceRootHint` is omitted when not set. When `fileExists: false` the `presets` array is empty and no `error` is present. When the file exists but fails to load, `error` contains a structured error object and `presets` is empty.
+
+### `list_presets` — error codes
+
+| Code | Meaning |
+|------|---------|
+| `git_not_found` | `git` binary not on `PATH`. |
+| `not_a_git_repository` | Root is not inside a git repository (reported inline in the `roots[*].error` field, not top-level). |
+| `invalid_json` | Preset file is not valid JSON (inline in `roots[*].error`). |
+| `invalid_schema` | Preset file fails schema validation (inline in `roots[*].error`). |
+| `absolute_git_roots_exclusive` | `absoluteGitRoots` combined with `workspaceRoot`, `rootIndex`, or `allWorkspaceRoots: true`. |
+| `invalid_absolute_git_root` | An `absoluteGitRoots` entry is not a git-recognized directory. |
+| `absolute_git_roots_too_many` | More than 256 entries in `absoluteGitRoots`. |
+| `absolute_git_roots_empty` | `absoluteGitRoots` resolved to zero toplevels. |
+| `root_index_out_of_range` | `rootIndex` exceeds the number of MCP file roots. |
+
+---
+
 ## JSON responses
 
 Tool JSON bodies are minified and contain only the payload — no `rethunkGitMcp` envelope. Current `MCP_JSON_FORMAT_VERSION` is **`"3"`**; server + format version are discoverable via MCP `initialize`. Payload keys (`groups`, `inventories`, `parity`, `roots`) are stable within a given format version. Preset-related responses may include **`presetSchemaVersion`**.
@@ -74,7 +297,7 @@ To keep responses compact, **optional fields are omitted when they would be empt
 | `workspaceRoot` | string | — | Explicit root; highest priority. |
 | `rootIndex` | int | — | Pick one of several MCP roots (0-based). |
 | `allWorkspaceRoots` | boolean | `false` | Fan out across all MCP roots. |
-| `format` | `"markdown"` \| `"json"` | `"markdown"` | Output format. |
+| `format` | `"markdown"` \| `"json"` \| `"oneline"` | `"markdown"` | Output format. `oneline` returns `<sha7> <subject>` per line with no headers (single root) or `### repo (branch)` separators per group (multi-root). Lowest-token option for post-commit verification. |
 
 ### `git_log` — JSON shape (`format: "json"`)
 
@@ -327,7 +550,7 @@ Do NOT do this: make two separate calls hoping to stage files incrementally. Tha
 
 | Parameter | Type | Notes |
 |-----------|------|-------|
-| `commits` | `{message: string, files: (string \| {path: string, lines: {from: number, to: number}})[]}[]` | Commits to create in order. 1–50 entries. Each `files` entry is either a path relative to the git root or a `{path, lines}` object for hunk-level staging. All paths must stay within the git toplevel. |
+| `commits` | `{message: string, files: (string \| {path: string, lines: {from: number, to: number}})[]}[]` | Commits to create in order. 1–50 entries. Each `files` entry is either: (a) a path relative to the git root, staged with `git add`; (b) a `{path, lines: {from, to}}` object for hunk-level staging — only unified-diff hunks overlapping the given 1-indexed line range are staged; or (c) a path to a **deleted tracked file** (missing on disk but tracked in HEAD), which is staged as a removal via `git rm --cached` — combining `{path, lines}` with a deleted file is an error. All paths must stay within the git toplevel. |
 | `push` | `"never"` \| `"after"` | Default `"never"`. `"after"` pushes the current branch to its upstream **once all commits succeed**. Never auto-sets upstream — branches without an upstream fail with `push_no_upstream`. Commits are **not** rolled back on push failure. Enum reserved for future modes such as `"force-with-lease"`. |
 | `dryRun` | boolean | Default `false`. When `true`, stages each entry, reports what would be committed (`staged`, `diffStat`), then unstages everything without writing commits. |
 | `workspaceRoot` | string | Explicit root; highest priority. |
@@ -373,7 +596,7 @@ The `push` object is present only when `push: "after"` was requested **and** eve
 | Code | Meaning |
 |------|---------|
 | `path_escapes_repository` | One of the listed file paths resolves outside the git toplevel. |
-| `stage_failed` | `git add` failed (e.g. untracked path or permission error). |
+| `stage_failed` | Staging failed. `git add` error for modified/new files; `git rm --cached` error for deleted files (e.g. path never tracked in HEAD); `{path, lines}` on a deleted file. |
 | `commit_failed` | `git commit` failed (e.g. nothing staged, hooks rejected). |
 | `not_a_git_repository` | The resolved workspace root is not inside a git repository. |
 
@@ -457,8 +680,9 @@ On conflict: top-level `ok` is `false`, the conflicting entry has `ok: false` wi
 |-----------|------|-------|
 | `sources` | `string[]` | Source specs. 1–50 entries. Each entry is one of: a full/short SHA, an `A..B` / `A...B` range, or a branch name. Branch names expand to `onto..<branch>` (oldest-first). |
 | `onto` | string | Destination branch. Defaults to the currently checked-out branch. Rejected when HEAD is detached. |
-| `deleteMergedBranches` | boolean | Default `false`. After all commits apply, delete each **branch-kind** source locally (`git branch -d`) when it is fully merged into the destination by SHA-reachability (not patch-equivalence). Protected names always skipped; never touches remote refs. |
+| `deleteMergedBranches` | boolean | Default `false`. After all commits apply, delete each **branch-kind** source locally. Deletion uses **patch-id equivalence** by default — correct for cherry-pick workflows where SHA differs but diff is identical. Protected names always skipped; never touches remote refs. |
 | `deleteMergedWorktrees` | boolean | Default `false`. After success, remove any local worktree attached to a branch-kind source (`git worktree remove`). Protected tails always skipped. |
+| `strictMergedRefEquality` | boolean | Default `false`. When `true`, branch deletion uses strict SHA-reachability (`git branch -d` ancestry semantics) instead of patch-id equivalence. Use when you need git's exact ancestry guarantee rather than content equivalence. |
 | `workspaceRoot`, `rootIndex`, `format` | — | Standard workspace pick + output format. |
 
 ### `git_cherry_pick` — JSON shape (`format: "json"`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rethunk/mcp-multi-root-git",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "MCP stdio server: multi-root git status, inventory, and HEAD parity checks. Generic tools usable by any workspace.",
   "type": "module",
   "private": false,
@@ -68,9 +68,19 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.14",
-    "@types/node": "^25.6.0",
+    "@biomejs/biome": "^2.4.15",
+    "@types/node": "^25.8.0",
     "rimraf": "^6.1.3",
     "typescript": "^6.0.3"
+  },
+  "overrides": {
+    "@hono/node-server": "^1.19.14",
+    "hono": "^4.12.18",
+    "fast-uri": "^3.1.2",
+    "postcss": "^8.5.10",
+    "vite": "^7.3.2",
+    "ip-address": "^10.1.1",
+    "axios": "^1.15.2",
+    "follow-redirects": "^1.15.12"
   }
 }

package/schemas/batch_commit.json

@@ -88,7 +88,7 @@
                 }
               ]
             },
-            "description": "Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging."
+            "description": "Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging. Deleted files (missing on disk but tracked in HEAD) are staged as removals via `git rm --cached`. Combining { path, lines } with a deleted file is an error."
           }
         },
         "required": [

package/schemas/git_cherry_pick.json

@@ -50,6 +50,11 @@
       "default": false,
       "description": "After success, remove any local worktree attached to a branch-kind source (`git worktree remove`). Protected tails always skipped.",
       "type": "boolean"
+    },
+    "strictMergedRefEquality": {
+      "default": false,
+      "description": "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.",
+      "type": "boolean"
     }
   },
   "required": [
@@ -57,7 +62,8 @@
     "format",
     "sources",
     "deleteMergedBranches",
-    "deleteMergedWorktrees"
+    "deleteMergedWorktrees",
+    "strictMergedRefEquality"
   ],
   "additionalProperties": false
 }

package/schemas/git_log.json

@@ -29,10 +29,12 @@
     },
     "format": {
       "default": "markdown",
+      "description": "`markdown` (default): headed sections per root. `json`: structured groups array. `oneline`: `<sha7> <subject>` per line, no headers (single-root) or `### repo (branch)` separator per group (multi-root). Lowest-token option for post-commit verification.",
       "type": "string",
       "enum": [
         "markdown",
-        "json"
+        "json",
+        "oneline"
       ]
     },
     "since": {

package/tool-parameters.schema.json

@@ -266,10 +266,12 @@
         },
         "format": {
           "default": "markdown",
+          "description": "`markdown` (default): headed sections per root. `json`: structured groups array. `oneline`: `<sha7> <subject>` per line, no headers (single-root) or `### repo (branch)` separator per group (multi-root). Lowest-token option for post-commit verification.",
           "type": "string",
           "enum": [
             "markdown",
-            "json"
+            "json",
+            "oneline"
           ]
         },
         "since": {
@@ -674,7 +676,7 @@
                     }
                   ]
                 },
-                "description": "Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging."
+                "description": "Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging. Deleted files (missing on disk but tracked in HEAD) are staged as removals via `git rm --cached`. Combining { path, lines } with a deleted file is an error."
               }
             },
             "required": [
@@ -884,6 +886,11 @@
           "default": false,
           "description": "After success, remove any local worktree attached to a branch-kind source (`git worktree remove`). Protected tails always skipped.",
           "type": "boolean"
+        },
+        "strictMergedRefEquality": {
+          "default": false,
+          "description": "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.",
+          "type": "boolean"
         }
       },
       "required": [
@@ -891,7 +898,8 @@
         "format",
         "sources",
         "deleteMergedBranches",
-        "deleteMergedWorktrees"
+        "deleteMergedWorktrees",
+        "strictMergedRefEquality"
       ],
       "additionalProperties": false
     },