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

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

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
 import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
-import { isSafeGitRefToken } from "./git-refs.js";
-import { jsonRespond, spreadDefined } from "./json.js";
+import { isSafeGitCommitIsh } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
 /**
@@ -125,17 +125,50 @@ function parsePorcelain(output) {
     return result;
 }
 // ---------------------------------------------------------------------------
+// Run-length grouping
+// ---------------------------------------------------------------------------
+/**
+ * Collapse per-line blame records into one group per contiguous same-commit
+ * run, so commit metadata (sha/author/date/summary) is emitted once per run
+ * instead of once per line.
+ */
+function groupBlameLines(lines) {
+    const groups = [];
+    let current;
+    for (const l of lines) {
+        if (current && current.sha === l.sha && current.endLine === l.line - 1) {
+            current.endLine = l.line;
+            current.lines.push({ line: l.line, content: l.content });
+            continue;
+        }
+        current = {
+            sha: l.sha,
+            author: l.author,
+            date: l.date,
+            summary: l.summary,
+            startLine: l.line,
+            endLine: l.line,
+            lines: [{ line: l.line, content: l.content }],
+        };
+        groups.push(current);
+    }
+    return groups;
+}
+// ---------------------------------------------------------------------------
 // Markdown rendering
 // ---------------------------------------------------------------------------
 function renderBlameMarkdown(result) {
     const header = result.ref !== undefined
         ? `# git blame ${result.ref} -- ${result.path}`
         : `# git blame ${result.path}`;
-    const rows = result.lines.map((l) => {
-        const sha7 = l.sha.slice(0, 7);
-        return `${sha7} (${l.author} ${l.date}) ${l.content}`;
-    });
-    return [`${header}`, "", "```", ...rows, "```"].join("\n");
+    const out = [header];
+    for (const g of result.groups) {
+        out.push("", `## ${g.sha.slice(0, 7)} ${g.author} ${g.date} — ${g.summary} (lines ${g.startLine}–${g.endLine})`, "```", ...g.lines.map((l) => `${l.line}: ${l.content}`), "```");
+    }
+    if (result.truncated) {
+        out.push("", `_(truncated — ${result.omittedLines} more line(s) not shown; raise maxLines)_`);
+    }
+    return out.join("\n");
 }
 // ---------------------------------------------------------------------------
 // Tool registration
@@ -143,31 +176,38 @@ function renderBlameMarkdown(result) {
 export function registerGitBlameTool(server) {
     server.addTool({
         name: "git_blame",
-        description: "Annotate each line of a file with the commit SHA, author, date, and summary that last modified it. Optionally restrict to a commit-ish ref and/or a line range.",
+        description: "File authorship, grouped into contiguous same-commit line runs (sha, author, date, summary once per run). Optionally restrict to a commit-ish ref and/or a line range.",
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
+        parameters: WorkspacePickSchema.extend({
             path: z.string().min(1).describe("Repo-relative path to the file to blame."),
-            ref: z.string().optional().describe("Optional commit-ish (SHA, branch, tag) to blame at."),
+            ref: z
+                .string()
+                .optional()
+                .describe('Optional commit-ish (SHA, branch, tag) to blame at. Ancestor notation is accepted (e.g. "HEAD~3", "main^2").'),
             startLine: z
                 .number()
                 .int()
                 .min(1)
+                .max(1000000)
                 .optional()
                 .describe("First line of the range to blame (1-based). Requires endLine."),
             endLine: z
                 .number()
                 .int()
                 .min(1)
+                .max(1000000)
                 .optional()
                 .describe("Last line of the range to blame (1-based, inclusive). Requires startLine."),
+            maxLines: z
+                .number()
+                .int()
+                .min(1)
+                .max(10000)
+                .optional()
+                .default(2000)
+                .describe("Max blamed lines to return. Default: 2000."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -181,7 +221,7 @@ export function registerGitBlameTool(server) {
             }
             // Ref validation
             if (args.ref !== undefined) {
-                if (!isSafeGitRefToken(args.ref)) {
+                if (!isSafeGitCommitIsh(args.ref)) {
                     return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
                 }
             }
@@ -212,11 +252,18 @@ export function registerGitBlameTool(server) {
                     detail: (r.stderr || r.stdout).trim(),
                 });
             }
-            const blameLines = parsePorcelain(r.stdout);
+            const allLines = parsePorcelain(r.stdout);
+            const maxLines = args.maxLines ?? 2000;
+            const truncated = allLines.length > maxLines;
+            const blameLines = truncated ? allLines.slice(0, maxLines) : allLines;
             const blameJson = {
                 ...spreadDefined("ref", args.ref),
                 path: args.path,
-                lines: blameLines,
+                groups: groupBlameLines(blameLines),
+                ...spreadWhen(truncated, {
+                    truncated: true,
+                    omittedLines: allLines.length - maxLines,
+                }),
             };
             if (args.format === "json") {
                 return jsonRespond(blameJson);

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

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { isProtectedBranch, isSafeGitAncestorRef, isSafeGitRefToken } from "./git-refs.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Resolve a ref (branch/commit-ish) to its full SHA; `null` if unresolvable. */
+async function getRefSha(gitTop, ref) {
+    const result = await spawnGitAsync(gitTop, [
+        "rev-parse",
+        "--verify",
+        "--quiet",
+        `${ref}^{commit}`,
+    ]);
+    if (!result.ok)
+        return null;
+    const sha = result.stdout.trim();
+    return sha === "" ? null : sha;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitBranchTool(server) {
+    server.addTool({
+        name: "git_branch",
+        description: "Create, delete, or rename a local git branch. `action: 'create'` makes `name` from `from` " +
+            "(default HEAD); `action: 'delete'` removes `name` (`force: true` for an unmerged branch, `-D`); " +
+            "`action: 'rename'` renames `name` to `newName`. Refuses protected branch names " +
+            "(main/master/dev/develop/stable/trunk/prod/production/release*/hotfix*) in any role.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            action: z.enum(["create", "delete", "rename"]).describe("Which branch operation to perform."),
+            name: z
+                .string()
+                .min(1)
+                .describe("Branch name to create/delete, or the existing branch name for rename."),
+            from: z
+                .string()
+                .optional()
+                .describe("Commit-ish to base a new branch on (create only). Default: HEAD."),
+            newName: z.string().optional().describe("New branch name (required for rename)."),
+            force: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Force-delete an unmerged branch (`git branch -D`). Delete only; never overrides protected-branch rejection."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const { gitTop } = pre;
+            const name = args.name.trim();
+            if (!isSafeGitRefToken(name)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: name });
+            }
+            if (isProtectedBranch(name)) {
+                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch: name });
+            }
+            if (args.action === "create") {
+                const fromRef = (args.from ?? "HEAD").trim();
+                if (!isSafeGitAncestorRef(fromRef)) {
+                    return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: fromRef });
+                }
+                const sha = await getRefSha(gitTop, fromRef);
+                if (!sha) {
+                    return jsonRespond({ error: ERROR_CODES.REF_NOT_FOUND, ref: fromRef });
+                }
+                const createResult = await spawnGitAsync(gitTop, ["branch", name, fromRef]);
+                if (!createResult.ok) {
+                    return jsonRespond({
+                        error: ERROR_CODES.BRANCH_CREATE_FAILED,
+                        detail: (createResult.stderr || createResult.stdout).trim(),
+                    });
+                }
+                return respond(args.format, { action: "create", branch: name, sha }, fromRef);
+            }
+            if (args.action === "delete") {
+                const sha = await getRefSha(gitTop, name);
+                if (!sha) {
+                    return jsonRespond({ error: ERROR_CODES.REF_NOT_FOUND, ref: name });
+                }
+                const deleteArgs = ["branch", args.force ? "-D" : "-d", name];
+                const deleteResult = await spawnGitAsync(gitTop, deleteArgs);
+                if (!deleteResult.ok) {
+                    return jsonRespond({
+                        error: ERROR_CODES.BRANCH_DELETE_FAILED,
+                        detail: (deleteResult.stderr || deleteResult.stdout).trim(),
+                    });
+                }
+                return respond(args.format, { action: "delete", branch: name, sha });
+            }
+            // action === "rename"
+            const newName = args.newName?.trim();
+            if (!newName) {
+                return jsonRespond({ error: ERROR_CODES.MISSING_NEW_NAME });
+            }
+            if (!isSafeGitRefToken(newName)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: newName });
+            }
+            if (isProtectedBranch(newName)) {
+                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch: newName });
+            }
+            const renameResult = await spawnGitAsync(gitTop, ["branch", "-m", name, newName]);
+            if (!renameResult.ok) {
+                return jsonRespond({
+                    error: ERROR_CODES.BRANCH_RENAME_FAILED,
+                    detail: (renameResult.stderr || renameResult.stdout).trim(),
+                });
+            }
+            const sha = await getRefSha(gitTop, newName);
+            if (!sha) {
+                return jsonRespond({
+                    error: ERROR_CODES.BRANCH_RENAME_FAILED,
+                    detail: `renamed '${name}' to '${newName}' but could not resolve its SHA`,
+                });
+            }
+            return respond(args.format, { action: "rename", branch: newName, sha }, undefined, name);
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Output rendering
+// ---------------------------------------------------------------------------
+function respond(format, result, from, renamedFrom) {
+    if (format === "json") {
+        return jsonRespond(result);
+    }
+    const lines = [];
+    if (result.action === "create") {
+        lines.push(`# Branch created: ${result.branch}`);
+        lines.push("");
+        lines.push(`**From:** ${from ?? "HEAD"}`);
+    }
+    else if (result.action === "delete") {
+        lines.push(`# Branch deleted: ${result.branch}`);
+    }
+    else {
+        lines.push(`# Branch renamed: ${renamedFrom ?? "?"} → ${result.branch}`);
+    }
+    lines.push(`**SHA:** \`${result.sha}\``);
+    return lines.join("\n");
+}

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

@@ -5,6 +5,8 @@ import { commitListBetween, conflictPaths, getCurrentBranch, isContentEquivalent
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
+/** Hard cap on SHAs fed to a single `git cherry-pick` (ARG_MAX / runtime guard). */
+export const MAX_CHERRY_PICK_COMMITS = 100;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -15,8 +17,13 @@ async function cherryPickHead(gitTop) {
     const sha = r.stdout.trim();
     return sha === "" ? undefined : sha;
 }
-async function abortCherryPick(gitTop) {
-    await spawnGitAsync(gitTop, ["cherry-pick", "--abort"]);
+/** Result of `git cherry-pick --abort` — callers must check `ok` before claiming a clean abort. */
+export async function abortCherryPick(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["cherry-pick", "--abort"]);
+    if (r.ok)
+        return { ok: true };
+    const detail = (r.stderr || r.stdout).trim();
+    return detail === "" ? { ok: false } : { ok: false, detail };
 }
 async function branchExists(gitTop, name) {
     const r = await spawnGitAsync(gitTop, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]);
@@ -96,6 +103,7 @@ export function registerGitCherryPickTool(server) {
         name: "git_cherry_pick",
         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. " +
+            `Hard-capped at ${MAX_CHERRY_PICK_COMMITS} commits per call (after dedupe). ` +
             "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.",
@@ -104,7 +112,7 @@ export function registerGitCherryPickTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             sources: z
                 .array(z.string().min(1))
                 .min(1)
@@ -123,19 +131,39 @@ export function registerGitCherryPickTool(server) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("Remove local worktrees on branch-kind sources after success. Protected tails skipped."),
+                .describe("Remove local worktrees on branch-kind sources after success. Protected names and path tails skipped."),
             strictMergedRefEquality: z
                 .boolean()
                 .optional()
                 .default(false)
                 .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)."),
+            onConflict: z
+                .enum(["abort", "pause"])
+                .optional()
+                .default("abort")
+                .describe("`abort` (default): on conflict, run `cherry-pick --abort` and roll back the whole range " +
+                "(unchanged behavior). `pause`: on conflict, leave the conflict and native cherry-pick " +
+                "sequencer state in place — commits already applied stay applied — so it can be resolved " +
+                "and resumed via `git_cherry_pick_continue`."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
+            // --- Guard: refuse when a cherry-pick is already in progress (native sequencer state,
+            // read live off CHERRY_PICK_HEAD — this server is stateless per call). Checked before the
+            // dirty-tree refusal below so callers get a specific, actionable error instead of the
+            // generic working_tree_dirty. ---
+            const alreadyInProgress = await cherryPickHead(gitTop);
+            if (alreadyInProgress) {
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_IN_PROGRESS,
+                    commit: alreadyInProgress,
+                });
+            }
+            const onConflict = args.onConflict ?? "abort";
             // --- Resolve destination ---
             const startBranch = await getCurrentBranch(gitTop);
             const onto = args.onto?.trim() || startBranch;
@@ -176,6 +204,13 @@ export function registerGitCherryPickTool(server) {
             }
             // --- Dedupe + skip already-present ---
             const { picks, perSourceKept } = await filterAndDedupe(gitTop, onto, resolved);
+            if (picks.length > MAX_CHERRY_PICK_COMMITS) {
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_TOO_MANY_COMMITS,
+                    picked: picks.length,
+                    max: MAX_CHERRY_PICK_COMMITS,
+                });
+            }
             // --- Apply cherry-pick (single atomic call) ---
             // `--empty=drop` silently drops commits that would produce no change against the
             // current tip — makes the tool idempotent when the same patch is re-applied.
@@ -188,13 +223,33 @@ export function registerGitCherryPickTool(server) {
                 if (!r.ok) {
                     const failedSha = await cherryPickHead(gitTop);
                     const paths = await conflictPaths(gitTop);
-                    await abortCherryPick(gitTop);
-                    conflict = {
-                        stage: "cherry-pick",
-                        ...spreadDefined("commit", failedSha),
-                        paths,
-                        detail: (r.stderr || r.stdout).trim(),
-                    };
+                    if (onConflict === "pause") {
+                        // Leave the conflict + native sequencer state in place. Commits already
+                        // applied before the conflicting one stay applied — compute that count
+                        // cheaply from the HEAD advance so far (resumable via git_cherry_pick_continue).
+                        const adv = await spawnGitAsync(gitTop, ["rev-list", "--count", `${preHead}..HEAD`]);
+                        appliedCount = adv.ok ? parseInt(adv.stdout.trim(), 10) || 0 : 0;
+                        conflict = {
+                            stage: "cherry-pick",
+                            paused: true,
+                            ...spreadDefined("commit", failedSha),
+                            paths,
+                            detail: (r.stderr || r.stdout).trim(),
+                        };
+                    }
+                    else {
+                        const abort = await abortCherryPick(gitTop);
+                        conflict = {
+                            stage: "cherry-pick",
+                            ...spreadDefined("commit", failedSha),
+                            paths,
+                            detail: (r.stderr || r.stdout).trim(),
+                            ...spreadWhen(!abort.ok, {
+                                abortFailed: true,
+                                ...spreadDefined("abortDetail", abort.detail),
+                            }),
+                        };
+                    }
                 }
                 else {
                     // Actual commits written = HEAD advance count (empty-drop may skip some).
@@ -265,18 +320,29 @@ export function registerGitCherryPickTool(server) {
                     ...spreadWhen(conflict !== undefined, {
                         conflict: {
                             stage: conflict?.stage ?? "cherry-pick",
+                            ...spreadWhen(conflict?.paused === true, { paused: true }),
                             ...spreadDefined("commit", conflict?.commit),
                             paths: conflict?.paths ?? [],
                             ...spreadDefined("detail", conflict?.detail),
+                            ...spreadWhen(conflict?.abortFailed === true, {
+                                abortFailed: true,
+                                ...spreadDefined("abortDetail", conflict?.abortDetail),
+                            }),
                         },
                     }),
+                    ...spreadWhen(conflict?.abortFailed === true, {
+                        error: ERROR_CODES.CHERRY_PICK_ABORT_FAILED,
+                        ...spreadDefined("abortDetail", conflict?.abortDetail),
+                    }),
                 });
             }
             // --- Markdown ---
             const lines = [];
             const header = allOk
                 ? `# Cherry-pick onto \`${onto}\`: ${appliedCount} commit(s) applied`
-                : `# Cherry-pick onto \`${onto}\`: stopped on conflict after ${appliedCount} commit(s)`;
+                : conflict?.paused
+                    ? `# Cherry-pick onto \`${onto}\`: paused on conflict after ${appliedCount} commit(s)`
+                    : `# Cherry-pick onto \`${onto}\`: stopped on conflict after ${appliedCount} commit(s)`;
             lines.push(header, "");
             for (const s of perSourceReport) {
                 const kept = perSourceKept.get(s.raw)?.length ?? 0;
@@ -293,8 +359,151 @@ export function registerGitCherryPickTool(server) {
                     lines.push(`  conflict: ${p}`);
                 if (conflict.detail)
                     lines.push(`  detail: ${conflict.detail}`);
+                if (conflict.paused) {
+                    lines.push("  Paused: cherry-pick left in progress. Resolve the conflict, then call `git_cherry_pick_continue`.");
+                }
+                if (conflict.abortFailed) {
+                    lines.push(`  Error: ${ERROR_CODES.CHERRY_PICK_ABORT_FAILED}${conflict.abortDetail ? ` — ${conflict.abortDetail}` : ""}`);
+                }
             }
             return lines.join("\n");
         },
     });
 }
+function renderCherryPickContinueMarkdown(action, ok, applied, headSha, conflict) {
+    if (action === "abort") {
+        return ok
+            ? `# Cherry-pick abort\nAborted. HEAD restored to \`${headSha ?? "?"}\`.`
+            : "# Cherry-pick abort\nAbort failed — see error.";
+    }
+    if (conflict) {
+        const lines = [
+            `# Cherry-pick continue: paused on conflict after ${applied} commit(s)`,
+            "",
+            `Conflict at commit \`${conflict.commit ?? "?"}\` (${conflict.stage}):`,
+        ];
+        for (const p of conflict.paths)
+            lines.push(`  conflict: ${p}`);
+        if (conflict.detail)
+            lines.push(`  detail: ${conflict.detail}`);
+        lines.push("  Paused: cherry-pick still in progress. Resolve the conflict, then call `git_cherry_pick_continue` again.");
+        return lines.join("\n");
+    }
+    return `# Cherry-pick continue: ${applied} commit(s) applied\nHEAD now \`${headSha ?? "?"}\`.`;
+}
+export function registerGitCherryPickContinueTool(server) {
+    server.addTool({
+        name: "git_cherry_pick_continue",
+        description: "Resume or abort a cherry-pick left in progress — typically by `git_cherry_pick`'s " +
+            '`onConflict: "pause"`, but this tool is stateless and reads `CHERRY_PICK_HEAD` / the native ' +
+            "sequencer live off `.git`, so it works regardless of how the in-progress state was left. " +
+            '`action: "continue"` (default) requires every previously conflicted path to be staged (no ' +
+            "remaining unmerged entries — `cherry_pick_unresolved_paths` otherwise), then runs " +
+            "`git -c core.editor=true cherry-pick --continue` so git's sequencer both commits the resolved " +
+            "pick and resumes through any remaining picks in the same range. If a *later* pick then " +
+            "conflicts, the response reports it the same way as a paused `git_cherry_pick` call (`conflict." +
+            'paused: true`) so this tool can be called again to keep walking the range. `action: "abort"` ' +
+            "rolls back the whole in-progress cherry-pick via `git cherry-pick --abort`.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            action: z
+                .enum(["continue", "abort"])
+                .optional()
+                .default("continue")
+                .describe('"continue" (default): resolve conflicts, stage them, then resume the sequencer. ' +
+                '"abort": roll back to the pre-cherry-pick HEAD.'),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            const action = args.action ?? "continue";
+            const inProgressSha = await cherryPickHead(gitTop);
+            if (!inProgressSha) {
+                return jsonRespond({ error: ERROR_CODES.NO_CHERRY_PICK_IN_PROGRESS });
+            }
+            const preHeadProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const preHead = preHeadProbe.ok ? preHeadProbe.stdout.trim() : "";
+            // --- abort: reuse the same hardened abort helper/reporting as git_cherry_pick ---
+            if (action === "abort") {
+                const abort = await abortCherryPick(gitTop);
+                if (!abort.ok) {
+                    return jsonRespond({
+                        ok: false,
+                        action: "abort",
+                        error: ERROR_CODES.CHERRY_PICK_ABORT_FAILED,
+                        ...spreadDefined("abortDetail", abort.detail),
+                    });
+                }
+                const headProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+                const headSha = headProbe.ok ? headProbe.stdout.trim() : undefined;
+                if (args.format === "json") {
+                    return jsonRespond({ ok: true, action: "abort", ...spreadDefined("headSha", headSha) });
+                }
+                return renderCherryPickContinueMarkdown("abort", true, 0, headSha);
+            }
+            // --- continue: precheck no unmerged paths remain ---
+            const unmerged = await conflictPaths(gitTop);
+            if (unmerged.length > 0) {
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_UNRESOLVED_PATHS,
+                    paths: unmerged,
+                });
+            }
+            // `-c core.editor=true` avoids launching an interactive editor for the reused commit message.
+            const r = await spawnGitAsync(gitTop, [
+                "-c",
+                "core.editor=true",
+                "cherry-pick",
+                "--continue",
+            ]);
+            if (!r.ok) {
+                const failedSha = await cherryPickHead(gitTop);
+                const paths = failedSha ? await conflictPaths(gitTop) : [];
+                if (failedSha && paths.length > 0) {
+                    // A later commit in the same range conflicted — report it the same shape as a
+                    // paused git_cherry_pick call so the caller can loop this tool to resolution.
+                    const adv = await spawnGitAsync(gitTop, ["rev-list", "--count", `${preHead}..HEAD`]);
+                    const applied = adv.ok ? parseInt(adv.stdout.trim(), 10) || 0 : 0;
+                    const conflict = {
+                        stage: "cherry-pick",
+                        paused: true,
+                        ...spreadDefined("commit", failedSha),
+                        paths,
+                        ...spreadDefined("detail", (r.stderr || r.stdout).trim() || undefined),
+                    };
+                    if (args.format === "json") {
+                        return jsonRespond({ ok: false, action: "continue", applied, conflict });
+                    }
+                    return renderCherryPickContinueMarkdown("continue", false, applied, undefined, conflict);
+                }
+                // Not a new conflict (e.g. the resolved pick would produce an empty commit) —
+                // surface a generic, non-resumable-loop error with whatever detail git gave.
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_CONTINUE_FAILED,
+                    ...spreadDefined("commit", failedSha),
+                    detail: (r.stderr || r.stdout).trim(),
+                });
+            }
+            // --- success: sequencer completed the resolved pick and any remaining ones ---
+            const adv = await spawnGitAsync(gitTop, ["rev-list", "--count", `${preHead}..HEAD`]);
+            const applied = adv.ok ? parseInt(adv.stdout.trim(), 10) || 0 : 0;
+            const headProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const headSha = headProbe.ok ? headProbe.stdout.trim() : undefined;
+            if (args.format === "json") {
+                return jsonRespond({
+                    ok: true,
+                    action: "continue",
+                    applied,
+                    ...spreadDefined("headSha", headSha),
+                });
+            }
+            return renderCherryPickContinueMarkdown("continue", true, applied, headSha);
+        },
+    });
+}