@icode-js/icode 3.3.0 → 3.4.0

package/README.md

@@ -334,7 +334,7 @@ icode push release test -r -y # 使用远程 MR 模式合并到多个目标分
 
 - 自动 `add + commit + push`
 - 存在冲突或未完成 Git 操作时会直接停止
-- 本地 merge 冲突会暂停在目标分支现场；解决后执行 `icode undo --recover continue`，或执行 `icode undo --recover abort` 中止
+- 本地 merge 冲突会暂停在目标分支现场；解决冲突后执行 `icode continue`，会自动暂存、推送该分支、继续处理剩下的目标分支并切回原分支；执行 `icode abort` 则放弃并切回原分支
 - 支持 `--ai-commit` 在 push 前自动生成并应用 AI 提交信息
 - 若仓库存在 husky/hooks/commitlint 规则，AI commit 会先扫描本地规范再生成提交信息
 - 支持把当前分支合并到多个目标分支
@@ -567,7 +567,31 @@ icode fixup a1b2c3d -a
 icode fixup a1b2c3d --no-rebase
 ```
 
-等同 `git commit --fixup=<commit>` + `git rebase -i --autosquash`，不会打开编辑器。冲突时用 `icode undo --recover continue|abort` 处理。
+等同 `git commit --fixup=<commit>` + `git rebase -i --autosquash`，不会打开编辑器。冲突时用 `icode continue` / `icode abort` 处理。
+
+### continue / abort
+
+冲突解决后继续：
+
+```bash
+icode continue
+```
+
+1. 检查冲突文件里是否还有 `<<<<<<<` / `>>>>>>>`，有就列出文件和行号，不会继续
+2. 自动 `git add` 已解决的文件
+3. 继续 merge / rebase / cherry-pick / revert（不会打开编辑器）
+4. 如果是 `push` / `migrate` / `sync` 中途冲突，接着把剩下的步骤做完：推送当前分支、处理剩余目标分支、切回原分支
+
+放弃：
+
+```bash
+icode abort
+```
+
+中止进行中的 Git 操作，切回原分支。已经推送成功的分支不会被撤回。
+
+有被中断的操作时，`icode ready` 会标出来，直接运行 `icode` 的菜单也会把“继续 / 放弃”放在最前面。
+`icode undo --recover continue|abort` 仍然可用，效果相同。
 
 ### rescue
 
@@ -619,7 +643,7 @@ icode migrate <sourceBranch> <targetBranch> --dry-run --json
 - 执行前要求工作区干净，且不能存在未完成的 merge/rebase/cherry-pick/revert
 - 支持 `--dry-run` 输出 checkout/pull/cherry-pick/push 计划，不产生 Git 副作用
 - 支持 `--json` 输出结构化计划或执行结果，适合 AI agent 消费
-- 如果迁移冲突，可使用 `icode undo --recover continue|abort|keep` 处理现场
+- 如果迁移冲突，解决后执行 `icode continue`（会接着迁移剩下的提交，带 `--push` 时自动推送并切回原分支），或执行 `icode abort` 放弃
 
 参数说明：
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@icode-js/icode",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Modern git workflow CLI with robust parent-repo and hook handling",
   "type": "module",
   "author": "C",
   "bin": {
-    "icode": "./bin/icode.js"
+    "icode": "bin/icode.js"
   },
   "scripts": {
     "test": "node --test",
@@ -19,7 +19,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/wandou-cc/icode-js.git"
+    "url": "git+https://github.com/wandou-cc/icode-js.git"
   },
   "homepage": "https://github.com/wandou-cc/icode-js",
   "license": "MIT",

package/src/cli.js

@@ -4,6 +4,7 @@ import { runCodeReviewCommand } from './commands/codereview.js'
 import { runCompletionCommand, runHiddenCompletionCommand } from './commands/completion.js'
 import { runCheckoutCommand } from './commands/checkout.js'
 import { runConfigCommand } from './commands/config.js'
+import { runAbortCommand, runContinueCommand } from './commands/continue.js'
 import { runDoctorCommand } from './commands/doctor.js'
 import { runExplainCommand } from './commands/explain.js'
 import { printMainHelp } from './commands/help.js'
@@ -27,6 +28,8 @@ import { asIcodeError, IcodeError } from './core/errors.js'
 import { normalizeLegacyArgs } from './core/cli/args.js'
 import { notifyIfCliUpdateAvailable } from './core/cli/update-notifier.js'
 import { chooseOne, isInteractiveTerminal } from './core/tools/interactive.js'
+import { c } from './core/tools/theme.js'
+import { inspectPausedWork } from './workflows/continue-workflow.js'
 import { logger } from './core/tools/logger.js'
 
 function isTruthy(value) {
@@ -80,6 +83,8 @@ const COMMANDS = {
   sync: runSyncCommand,
   clean: runCleanCommand,
   undo: runUndoCommand,
+  continue: runContinueCommand,
+  abort: runAbortCommand,
   rescue: runRescueCommand,
   stash: runStashCommand,
   sw: runSwCommand,
@@ -117,6 +122,7 @@ const MAIN_MENU = [
   { value: 'amend', label: 'amend', hint: '修改上一个提交' },
   { value: 'fixup', label: 'fixup', hint: '把改动合进更早的提交' },
   { value: 'undo', label: 'undo', hint: '撤销 / 回滚' },
+  { value: 'continue', label: 'continue', hint: '冲突解决后继续' },
   { value: 'rescue', label: 'rescue', hint: '找回丢失的提交和改动' },
   { value: 'clean', label: 'clean', hint: '清理已合并的分支' },
   { value: 'pr', label: 'pr create', hint: '创建 PR / MR' },
@@ -129,7 +135,21 @@ const MAIN_MENU = [
 ]
 
 async function pickCommandFromMenu() {
-  const picked = await chooseOne('要做什么？', MAIN_MENU, 0)
+  // 有被冲突打断的操作时，把“继续 / 放弃”放在最前面。
+  let paused = null
+  try {
+    paused = await inspectPausedWork({})
+  } catch {
+    paused = null
+  }
+  const menu = paused
+    ? [
+      { value: 'continue', label: c.yellow('continue'), hint: `冲突解决后继续：${paused.description}` },
+      { value: 'abort', label: 'abort', hint: '放弃被中断的操作并切回原分支' },
+      ...MAIN_MENU
+    ]
+    : MAIN_MENU
+  const picked = await chooseOne(paused ? `有被中断的操作（${paused.description}），要做什么？` : '要做什么？', menu, 0)
   // pr 从菜单进入时直接走创建流程。
   if (picked === 'pr') {
     await COMMANDS.pr(['create'])

package/src/commands/continue.js

@@ -0,0 +1,104 @@
+import { parseCommandArgs, printJson } from '../core/cli/output.js'
+import { c, print, renderBranchResults } from '../core/cli/render.js'
+import { confirm, isInteractiveTerminal } from '../core/tools/interactive.js'
+import { logger } from '../core/tools/logger.js'
+import { inspectPausedWork, runAbortWorkflow, runContinueWorkflow } from '../workflows/continue-workflow.js'
+
+const RESULT_LABELS = {
+  pushed: '已推送',
+  'merged-and-pushed': '已合并并推送',
+  'force-pushed': '已强推',
+  'skipped-protected': '已跳过（受保护分支）',
+  synced: '已同步',
+  'synced-and-pushed': '已同步并推送',
+  missing: '本地和远程都不存在'
+}
+
+function printContinueHelp() {
+  process.stdout.write(`
+Usage:
+  icode continue [options]
+
+解决冲突后继续刚才被打断的操作：
+  1. 检查冲突文件里是否还有 <<<<<<< / >>>>>>> 标记，有就列出文件和行号
+  2. 自动 git add 已解决的文件
+  3. 继续 merge / rebase / cherry-pick / revert
+  4. 如果是 push / migrate / sync 中途冲突，接着把剩下的步骤做完（推送、处理剩余分支、切回原分支）
+
+Options:
+  --json                 输出机器可读 JSON
+  --repo-mode <mode>     仓库模式: auto | strict
+  -h, --help             查看帮助
+`)
+}
+
+function printAbortHelp() {
+  process.stdout.write(`
+Usage:
+  icode abort [options]
+
+放弃刚才被冲突打断的操作：中止 merge / rebase / cherry-pick / revert，并切回原分支。
+已经推送成功的分支不会被撤回。
+
+Options:
+  -y, --yes              不再确认
+  --json                 输出机器可读 JSON
+  --repo-mode <mode>     仓库模式: auto | strict
+  -h, --help             查看帮助
+`)
+}
+
+export async function runContinueCommand(rawArgs) {
+  const { values } = parseCommandArgs(rawArgs)
+  if (values.help) {
+    printContinueHelp()
+    return
+  }
+
+  const result = await runContinueWorkflow({ repoMode: values['repo-mode'], silentLog: values.json })
+  if (values.json) {
+    printJson(result)
+    return result
+  }
+
+  if (result.summary.length) {
+    print('')
+    renderBranchResults(result.summary, RESULT_LABELS)
+    print('')
+  }
+  if (result.resumed) {
+    logger.success(`${result.description} 已全部完成${result.returnedTo ? c.gray(`，已切回 ${result.returnedTo}`) : ''}`)
+  }
+  return result
+}
+
+export async function runAbortCommand(rawArgs) {
+  const { values } = parseCommandArgs(rawArgs)
+  if (values.help) {
+    printAbortHelp()
+    return
+  }
+
+  if (!values.yes && !values.json && isInteractiveTerminal()) {
+    const paused = await inspectPausedWork({ repoMode: values['repo-mode'] })
+    if (paused) {
+      const accepted = await confirm(`放弃 ${paused.description}？冲突处理到一半的改动会丢弃`, false)
+      if (!accepted) {
+        logger.hint('已保留现场。处理完冲突后执行 icode continue。')
+        return
+      }
+    }
+  }
+
+  const result = await runAbortWorkflow({ repoMode: values['repo-mode'] })
+  if (values.json) {
+    printJson(result)
+    return result
+  }
+
+  logger.success(`已放弃 ${result.description || result.operation}${result.returnedTo ? c.gray(`，已切回 ${result.returnedTo}`) : ''}`)
+  if (result.done.length) {
+    logger.hint(`这些分支在中断前已推送，不会撤回: ${result.done.join(', ')}`)
+  }
+  return result
+}

package/src/commands/help.js

@@ -26,7 +26,9 @@ Usage:
   clean       清理已合并 / 远程已删除 / 长期未动的分支
 
 兜底:
-  undo        向导式撤销/回滚（revert/reset），处理未完成的 merge/rebase
+  continue    冲突解决后继续（自动暂存，并接着完成被打断的 push/migrate/sync）
+  abort       放弃被冲突打断的操作并切回原分支
+  undo        向导式撤销/回滚（revert/reset）
   rescue      找回恢复点和 reflog 里的提交
 
 协作与发布:
@@ -71,6 +73,7 @@ Examples:
   icode log --unpushed
   icode stash save -m "wip"
   icode clean --gone -y
+  icode continue
   icode undo --mode hard --ref HEAD~1
   icode rescue
   icode pr create --ai

package/src/commands/history.js

@@ -59,7 +59,7 @@ Options:
 
 Notes:
   等同于 git commit --fixup=<commit> && git rebase -i --autosquash（不会打开编辑器）。
-  发生冲突时用 icode undo --recover continue|abort 处理。执行前会自动创建恢复点。
+  发生冲突时用 icode continue / icode abort 处理。执行前会自动创建恢复点。
 
 Examples:
   icode fixup -a

package/src/commands/undo.js

@@ -18,7 +18,7 @@ Options:
   --mode <mode>          回滚模式: revert | soft | mixed | hard
   --ref <ref>            回滚目标，默认按 mode 自动给出
   --hash <hash>          按 commit hash 指定回滚目标（等同 --ref）
-  --recover <action>     冲突恢复策略: continue | abort | keep
+  --recover <action>     冲突恢复策略: continue | abort | keep（推荐直接用 icode continue / icode abort）
   --json                 输出机器可读 JSON，适合 AI agent 或脚本消费
   -y, --yes              自动确认（跳过确认提示）
   --repo-mode <mode>     仓库模式: auto(自动继承父仓库) | strict(禁止继承)

package/src/core/cli/completion.js

@@ -385,6 +385,8 @@ const ROOT_COMPLETION_SPEC = {
         { long: '--help', short: '-h' }
       ]
     },
+    continue: { options: [JSON_OPTION, REPO_MODE_OPTION, HELP_OPTION] },
+    abort: { options: BASIC_OPTIONS },
     sw: SW_NODE,
     switch: SW_NODE,
     stash: {

package/src/core/git/autostash.js

@@ -25,6 +25,11 @@ export async function withAutoStash(git, enabled, label, fn) {
     return await fn({ stashed: true, stashSha })
   } finally {
     const entry = (await git.stashList()).find((item) => item.hash === stashSha)
+    // 操作因冲突暂停时不要把改动倒回冲突现场，留在 stash 里等用户处理完再取回。
+    if (entry && (await git.getInProgressOperation())) {
+      logger.warn(`未提交的改动保存在 ${entry.ref}，处理完冲突（icode continue）后执行 \`icode stash pop\` 取回。`)
+      return
+    }
     if (entry) {
       try {
         await git.stashApply(entry.ref, { pop: true })

package/src/core/git/conflicts.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+// 只认 <<<<<<< 和 >>>>>>>：单独的 ======= 在 Markdown 等文件里可能是正常内容。
+const MARKER_PATTERN = /^(<{7}|>{7})(?: |$)/
+
+/**
+ * 找出文件中残留的冲突标记所在行号（从 1 开始）。
+ * 输入为文件绝对路径，输出行号数组；文件不存在（被删除）时返回空数组。
+ */
+export function findConflictMarkers(filePath) {
+  let content
+  try {
+    content = fs.readFileSync(filePath, 'utf8')
+  } catch {
+    return []
+  }
+  const lines = []
+  content.split('\n').forEach((line, index) => {
+    if (MARKER_PATTERN.test(line)) {
+      lines.push(index + 1)
+    }
+  })
+  return lines
+}
+
+/**
+ * 检查当前的冲突文件：已经没有冲突标记的视为已解决，还有标记的列出行号。
+ * 输入为 GitService，输出 { resolved: [path], unresolved: [{ file, lines }] }。
+ */
+export async function inspectConflicts(git) {
+  const conflicted = await git.listConflictedFiles()
+  const resolved = []
+  const unresolved = []
+  for (const file of conflicted) {
+    const lines = findConflictMarkers(path.resolve(git.cwd, file))
+    if (lines.length) {
+      unresolved.push({ file, lines })
+    } else {
+      resolved.push(file)
+    }
+  }
+  return { resolved, unresolved }
+}
+
+/**
+ * 把已解决（没有冲突标记）的文件自动 git add，省去手动暂存。
+ * 被删除的冲突文件用 git rm 标记。输出已暂存的文件列表。
+ */
+export async function stageResolvedConflicts(git, files) {
+  const staged = []
+  for (const file of files) {
+    const exists = fs.existsSync(path.resolve(git.cwd, file))
+    await git.exec(exists ? ['add', '--', file] : ['rm', '--quiet', '--', file])
+    staged.push(file)
+  }
+  return staged
+}

package/src/core/git/operation-state.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+// 多步骤命令（push 合并多个分支、migrate、sync）被冲突打断时，把剩下的步骤记在这里，
+// 解决冲突后 icode continue 读取它接着做完，icode abort 读取它切回原分支。
+// 放在 gitDir（每个 worktree 独立）下，不会被提交。
+
+const STATE_DIR = 'icode'
+const STATE_FILE = 'operation.json'
+
+function statePath(context) {
+  return path.resolve(context.gitDir, STATE_DIR, STATE_FILE)
+}
+
+/**
+ * 保存中断的操作。state 至少包含 command 与 originalBranch。
+ */
+export function saveOperationState(context, state) {
+  const filePath = statePath(context)
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, `${JSON.stringify({ ...state, savedAt: new Date().toISOString() }, null, 2)}\n`, 'utf8')
+  return filePath
+}
+
+/**
+ * 读取中断的操作，没有或损坏时返回 null。
+ */
+export function loadOperationState(context) {
+  const filePath = statePath(context)
+  if (!fs.existsSync(filePath)) {
+    return null
+  }
+  try {
+    const state = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    return state && typeof state === 'object' && state.command ? state : null
+  } catch {
+    return null
+  }
+}
+
+export function clearOperationState(context) {
+  fs.rmSync(statePath(context), { force: true })
+}
+
+/**
+ * 用一句话描述中断的操作，供 ready / 菜单 / continue 展示。
+ */
+export function describeOperationState(state) {
+  if (!state) {
+    return ''
+  }
+  if (state.command === 'push') {
+    const pending = [state.pendingPush, ...(state.remainingTargets || [])].filter(Boolean)
+    return `push ${state.sourceBranch}${pending.length ? ` → ${pending.join(', ')}` : ''}`
+  }
+  if (state.command === 'migrate') {
+    return `migrate ${state.sourceBranch} → ${state.targetBranch}`
+  }
+  if (state.command === 'sync') {
+    return `sync ${[state.currentBranch, ...(state.remainingTargets || [])].filter(Boolean).join(', ')}`
+  }
+  return state.command
+}

package/src/core/git/operations.js

@@ -0,0 +1,32 @@
+// 按 Git 操作类型执行 continue / abort，undo 与 continue/abort 命令共用。
+
+export const OPERATION_LABELS = {
+  merge: '合并 (merge)',
+  rebase: '变基 (rebase)',
+  'cherry-pick': '摘取提交 (cherry-pick)',
+  revert: '回滚 (revert)'
+}
+
+export async function continueOperation(git, operation) {
+  if (operation === 'revert') {
+    await git.revertContinue()
+  } else if (operation === 'merge') {
+    await git.mergeContinue()
+  } else if (operation === 'rebase') {
+    await git.rebaseContinue()
+  } else {
+    await git.cherryPickContinue()
+  }
+}
+
+export async function abortOperation(git, operation) {
+  if (operation === 'revert') {
+    await git.revertAbort()
+  } else if (operation === 'merge') {
+    await git.mergeAbort()
+  } else if (operation === 'rebase') {
+    await git.rebaseAbort()
+  } else {
+    await git.abortCherryPick()
+  }
+}

package/src/core/tools/logger.js

@@ -2,7 +2,9 @@ import { c, setColorStream } from './theme.js'
 
 let verboseEnabled = process.env.ICODE_LOG_LEVEL === 'verbose'
 // JSON 输出模式下 stdout 只留给结构化结果，普通日志改走 stderr。
-let logsToStderr = false
+// node --test 的子进程用 stdout 和主进程传递序列化数据，日志混在里面偶尔会导致解析失败，
+// 所以在测试子进程中默认把日志写到 stderr。
+let logsToStderr = Boolean(process.env.NODE_TEST_CONTEXT)
 
 function infoStream() {
   return logsToStderr ? process.stderr : process.stdout

package/src/workflows/continue-workflow.js

@@ -0,0 +1,233 @@
+import { IcodeError } from '../core/errors.js'
+import { inspectConflicts, stageResolvedConflicts } from '../core/git/conflicts.js'
+import { resolveGitContext } from '../core/git/context.js'
+import { clearOperationState, describeOperationState, loadOperationState, saveOperationState } from '../core/git/operation-state.js'
+import { abortOperation, continueOperation, OPERATION_LABELS } from '../core/git/operations.js'
+import { GitService } from '../core/git/service.js'
+import { logger } from '../core/tools/logger.js'
+import { ui } from '../core/tools/theme.js'
+import { mergeIntoTargetAndPush, pushCurrentBranch } from './push/local-merge-step.js'
+import { runSyncBranches } from './sync-workflow.js'
+
+async function openGit(options) {
+  const context = await resolveGitContext({ cwd: options.cwd, repoMode: options.repoMode })
+  return { context, git: new GitService(context) }
+}
+
+function formatUnresolved(unresolved) {
+  return unresolved
+    .map((item) => `  - ${item.file}（第 ${item.lines.slice(0, 5).join(', ')}${item.lines.length > 5 ? ' …' : ''} 行）`)
+    .join('\n')
+}
+
+/**
+ * 读取当前是否有需要继续/放弃的内容，供 ready / 主菜单提示。
+ * 输出 { operation, state, description } 或 null。
+ */
+export async function inspectPausedWork(options = {}) {
+  const { context, git } = await openGit(options)
+  const operation = await git.getInProgressOperation()
+  const state = loadOperationState(context)
+  if (!operation && !state) {
+    return null
+  }
+  return {
+    operation,
+    state,
+    description: [operation ? OPERATION_LABELS[operation] || operation : '', describeOperationState(state)].filter(Boolean).join(' · ')
+  }
+}
+
+// 冲突解决后把 push 剩下的步骤做完：推送已合并的目标分支、处理剩余目标、切回原分支。
+async function resumePush(git, context, state) {
+  const summary = [...(state.summary || [])]
+  const options = { ...(state.options || {}), yes: true }
+  const remaining = [...(state.remainingTargets || [])]
+
+  if (state.pendingPush) {
+    const remoteExists = await git.branchExistsRemote(state.pendingPush)
+    logger.info(`推送目标分支: ${ui.branch(state.pendingPush)}`)
+    await git.push(state.pendingPush, { setUpstream: !remoteExists, noVerify: options.noVerify })
+    summary.push({ branch: state.pendingPush, status: 'merged-and-pushed' })
+  }
+
+  for (let index = 0; index < remaining.length; index += 1) {
+    const branch = remaining[index]
+    try {
+      if (branch === state.sourceBranch) {
+        await git.checkout(state.sourceBranch)
+        summary.push(await pushCurrentBranch(git, branch, options, summary))
+      } else {
+        summary.push(await mergeIntoTargetAndPush(git, state.sourceBranch, branch, options, summary))
+      }
+    } catch (error) {
+      // 又遇到冲突：更新进度，等下一次 icode continue。
+      if (error?.code === 'PUSH_LOCAL_MERGE_PAUSED' && await git.getInProgressOperation()) {
+        const mergedTarget = error.meta?.step === 'merge-target'
+        saveOperationState(context, {
+          ...state,
+          pendingPush: mergedTarget ? branch : null,
+          remainingTargets: remaining.slice(mergedTarget ? index + 1 : index),
+          summary
+        })
+      }
+      throw error
+    }
+  }
+
+  return summary
+}
+
+async function resumeMigrate(git, state) {
+  const summary = []
+  if (state.push) {
+    logger.info(`推送目标分支: ${ui.branch(state.targetBranch)}`)
+    await git.push(state.targetBranch, { setUpstream: !state.targetExistsRemote, noVerify: state.options?.noVerify })
+    summary.push({ branch: state.targetBranch, status: 'pushed' })
+  }
+  return summary
+}
+
+async function resumeSync(git, context, state) {
+  const targets = [state.currentBranch, ...(state.remainingTargets || [])].filter(Boolean)
+  // runSyncBranches 结束时会自己切回原分支，并在再次冲突时更新进度。
+  clearOperationState(context)
+  const summary = await runSyncBranches(git, context, targets, state.options || {}, state.originalBranch, {
+    branch: state.currentBranch,
+    startAt: state.startAt || 'push'
+  })
+  return [...(state.summary || []), ...summary]
+}
+
+async function returnToOriginalBranch(git, state) {
+  const original = state?.originalBranch
+  if (!original) {
+    return ''
+  }
+  const current = await git.getCurrentBranch()
+  if (current !== original) {
+    await git.checkout(original)
+  }
+  return original
+}
+
+/**
+ * icode continue：检查冲突是否都已解决 -> 自动暂存 -> 继续 Git 操作 -> 接着完成 push/migrate/sync 剩下的步骤。
+ * 输出 { operation, staged, resumed, summary, returnedTo }。
+ */
+export async function runContinueWorkflow(options = {}) {
+  const { context, git } = await openGit(options)
+  const operation = await git.getInProgressOperation()
+  const state = loadOperationState(context)
+
+  if (!operation && !state) {
+    throw new IcodeError('没有需要继续的操作。', { code: 'CONTINUE_NOTHING', exitCode: 2 })
+  }
+
+  let staged = []
+  if (operation) {
+    const { resolved, unresolved } = await inspectConflicts(git)
+    if (unresolved.length) {
+      throw new IcodeError(
+        `还有 ${unresolved.length} 个文件存在冲突标记，请先处理：\n${formatUnresolved(unresolved)}\n处理完再执行 icode continue；想放弃可执行 icode abort。`,
+        { code: 'CONTINUE_UNRESOLVED_CONFLICTS', exitCode: 2, meta: { unresolved } }
+      )
+    }
+    staged = await stageResolvedConflicts(git, resolved)
+    if (staged.length && !options.silentLog) {
+      logger.info(`已自动暂存 ${staged.length} 个已解决的文件: ${staged.map(ui.path).join(' ')}`)
+    }
+
+    try {
+      await continueOperation(git, operation)
+    } catch (error) {
+      // rebase / cherry-pick 的下一个提交可能又冲突。
+      const still = await git.getInProgressOperation()
+      const next = still ? await inspectConflicts(git) : { unresolved: [] }
+      if (next.unresolved.length) {
+        throw new IcodeError(
+          `下一个提交又出现冲突：\n${formatUnresolved(next.unresolved)}\n处理完再执行 icode continue。`,
+          { code: 'CONTINUE_NEXT_CONFLICT', exitCode: 2, meta: { unresolved: next.unresolved }, cause: error }
+        )
+      }
+      throw new IcodeError(`继续 ${operation} 失败：${error.message.split('\n').slice(0, 4).join('\n')}`, {
+        code: 'CONTINUE_FAILED',
+        exitCode: 2,
+        cause: error
+      })
+    }
+  }
+
+  if (operation && !options.silentLog) {
+    logger.success(`${OPERATION_LABELS[operation] || operation} 已完成`)
+  }
+
+  let summary = []
+  if (state) {
+    if (state.command === 'push') {
+      summary = await resumePush(git, context, state)
+    } else if (state.command === 'migrate') {
+      summary = await resumeMigrate(git, state)
+    } else if (state.command === 'sync') {
+      summary = await resumeSync(git, context, state)
+    }
+  }
+
+  // 进度只在全部完成后清除；中途再次冲突时上面已经抛错并更新了进度。
+  let returnedTo = ''
+  if (state) {
+    if (state.command !== 'sync') {
+      returnedTo = await returnToOriginalBranch(git, state)
+    } else {
+      returnedTo = state.originalBranch || ''
+    }
+    clearOperationState(context)
+  }
+
+  return {
+    operation,
+    staged,
+    resumed: state ? state.command : '',
+    description: describeOperationState(state),
+    summary,
+    returnedTo,
+    repoRoot: context.topLevelPath
+  }
+}
+
+/**
+ * icode abort：中止进行中的 Git 操作，清除中断进度并切回原分支。
+ * 已经推送成功的分支不会被撤回。
+ */
+export async function runAbortWorkflow(options = {}) {
+  const { context, git } = await openGit(options)
+  const operation = await git.getInProgressOperation()
+  const state = loadOperationState(context)
+
+  if (!operation && !state) {
+    throw new IcodeError('没有需要放弃的操作。', { code: 'ABORT_NOTHING', exitCode: 2 })
+  }
+
+  if (operation) {
+    await abortOperation(git, operation)
+  }
+
+  let returnedTo = ''
+  if (state) {
+    try {
+      returnedTo = await returnToOriginalBranch(git, state)
+    } catch (error) {
+      logger.warn(`未能切回 ${state.originalBranch}: ${error.message.split('\n')[0]}`)
+    }
+    clearOperationState(context)
+  }
+
+  return {
+    operation,
+    aborted: state ? state.command : '',
+    description: describeOperationState(state),
+    done: (state?.summary || []).filter((item) => /pushed/.test(item.status)).map((item) => item.branch),
+    returnedTo,
+    repoRoot: context.topLevelPath
+  }
+}

package/src/workflows/history-workflow.js

@@ -193,8 +193,8 @@ export async function runFixupWorkflow(options = {}) {
     await git.rebaseOnto(parentSha, { autosquash: true, autostash: true, root: !parentSha })
   } catch (error) {
     throw new IcodeError(
-      'fixup 自动整理提交时发生冲突。解决冲突并 git add 后执行 `icode undo --recover continue`，' +
-        `或执行 \`icode undo --recover abort\` 放弃（之前的状态在恢复点 ${backup.id}）。`,
+      'fixup 自动整理提交时发生冲突。解决冲突后执行 `icode continue`，' +
+        `或执行 \`icode abort\` 放弃（之前的状态在恢复点 ${backup.id}）。`,
       { code: 'FIXUP_REBASE_CONFLICT', exitCode: 2, cause: error, meta: error.meta }
     )
   }

package/src/workflows/migrate-workflow.js

@@ -1,6 +1,7 @@
 import { IcodeError } from '../core/errors.js'
 import { ui, shortenHome } from '../core/tools/theme.js'
 import { createBackup } from '../core/git/backup.js'
+import { saveOperationState } from '../core/git/operation-state.js'
 import { resolveGitContext } from '../core/git/context.js'
 import { GitService } from '../core/git/service.js'
 import { chooseMany, chooseOne, isInteractiveTerminal } from '../core/tools/interactive.js'
@@ -628,8 +629,19 @@ export async function runMigrateWorkflow(options) {
     try {
       await git.cherryPick(commits)
     } catch (error) {
+      if (await git.getInProgressOperation()) {
+        saveOperationState(context, {
+          command: 'migrate',
+          sourceBranch,
+          targetBranch,
+          originalBranch,
+          push: Boolean(options.push),
+          targetExistsRemote,
+          options: { noVerify: Boolean(options.noVerify) }
+        })
+      }
       throw new IcodeError(
-        '迁移失败: cherry-pick 发生冲突。请先解决冲突后执行 `icode undo --recover continue`，或执行 `icode undo --recover abort` 回滚。',
+        `迁移暂停: cherry-pick 发生冲突，已停在 ${targetBranch}。解决冲突后执行 \`icode continue\` 接着迁移剩下的提交${options.push ? '并推送' : ''}，或执行 \`icode abort\` 放弃并切回原分支。`,
         {
           code: 'MIGRATE_CHERRY_PICK_FAILED',
           cause: error,
@@ -657,7 +669,8 @@ export async function runMigrateWorkflow(options) {
       repoRoot: context.topLevelPath
     }
   } finally {
-    if (originalBranch && originalBranch !== targetBranch) {
+    // 冲突暂停时留在目标分支上，方便直接解决冲突。
+    if (originalBranch && originalBranch !== targetBranch && !(await git.getInProgressOperation())) {
       try {
         await git.checkout(originalBranch)
       } catch (error) {

package/src/workflows/push/local-merge-step.js

@@ -33,7 +33,7 @@ export function buildLocalMergePauseError({ sourceBranch, targetBranch, step, er
   const conflict = isGitConflictFailure(error)
   const prefix = conflict ? '本地合并冲突' : '本地合并失败'
   const nextStep = conflict
-    ? '请解决冲突后执行 `icode undo --recover continue`，或执行 `icode undo --recover abort` 中止本次合并。'
+    ? '解决冲突后执行 `icode continue`（会自动暂存已解决的文件，并接着完成剩下的推送），或执行 `icode abort` 放弃并切回原分支。'
     : '请根据上面的 Git 错误修复后重试。'
 
   return new IcodeError(`${prefix}(${step}): ${sourceBranch} -> ${targetBranch}\n${reason}\n${nextStep}`, {

package/src/workflows/push-workflow.js

@@ -2,6 +2,7 @@ import { getRepoPolicy } from '../core/config/store.js'
 import { ui, shortenHome } from '../core/tools/theme.js'
 import { IcodeError } from '../core/errors.js'
 import { createBackup } from '../core/git/backup.js'
+import { saveOperationState } from '../core/git/operation-state.js'
 import { resolveGitContext } from '../core/git/context.js'
 import {
   assertNoConflictedFiles,
@@ -68,6 +69,28 @@ function validateForcePush(inputOptions, branchTargets, currentBranch, context,
   }
 }
 
+// 去掉会被跳过的受保护分支，只保留续做时真正要处理的分支。
+function filterRunnable(branches, protectedBranches, inputOptions) {
+  return branches.filter((branch) => !(protectedBranches.has(branch) && !inputOptions.forceProtected))
+}
+
+// 保存 push 中断时的进度：pendingPush 是已合并但还没推送的分支，remainingTargets 是还没处理的分支。
+function savePushState(context, inputOptions, sourceBranch, pendingPush, remainingTargets, summary) {
+  saveOperationState(context, {
+    command: 'push',
+    sourceBranch,
+    originalBranch: sourceBranch,
+    pendingPush,
+    remainingTargets,
+    options: {
+      noVerify: Boolean(inputOptions.noVerify),
+      createTarget: Boolean(inputOptions.createTarget),
+      yes: true
+    },
+    summary: summary.slice()
+  })
+}
+
 /**
  * 交互选择推送目标：只推当前分支（默认）/ 同时本地合并到其他分支 / 通过 PR 合并。
  * 输出 { targets, remoteMerge } 或 null（取消）。
@@ -215,13 +238,17 @@ export async function runPushWorkflow(inputOptions) {
         noRebase: true
       })
     } catch (error) {
-      throw buildLocalMergePauseError({
+      const pauseError = buildLocalMergePauseError({
         sourceBranch: context.defaultBranch,
         targetBranch: currentBranch,
         step: 'pull-main',
         error,
         summary
       })
+      if (await git.getInProgressOperation()) {
+        savePushState(context, inputOptions, currentBranch, null, filterRunnable(branchTargets, protectedBranches, inputOptions), summary)
+      }
+      throw pauseError
     }
   }
 
@@ -282,24 +309,32 @@ export async function runPushWorkflow(inputOptions) {
   const branchOptions = { ...inputOptions, expectedRemoteSha }
 
   try {
-    for (const targetBranch of branchTargets) {
+    for (let index = 0; index < branchTargets.length; index += 1) {
+      const targetBranch = branchTargets[index]
       if (protectedBranches.has(targetBranch) && !inputOptions.forceProtected) {
         logger.warn(`跳过受保护分支: ${ui.branch(targetBranch)}（可用 --force-protected 覆盖）`)
         summary.push({ branch: targetBranch, status: 'skipped-protected' })
         continue
       }
 
-      if (targetBranch === currentBranch) {
-        summary.push(await pushCurrentBranch(git, targetBranch, branchOptions, summary))
-        continue
-      }
-
-      if (inputOptions.remoteMerge) {
+      if (inputOptions.remoteMerge && targetBranch !== currentBranch) {
         remoteMergeTargets.push(targetBranch)
         continue
       }
 
-      summary.push(await mergeIntoTargetAndPush(git, currentBranch, targetBranch, branchOptions, summary))
+      try {
+        summary.push(targetBranch === currentBranch
+          ? await pushCurrentBranch(git, targetBranch, branchOptions, summary)
+          : await mergeIntoTargetAndPush(git, currentBranch, targetBranch, branchOptions, summary))
+      } catch (error) {
+        // 冲突暂停：记下剩余步骤，icode continue 会推送当前目标并处理剩下的分支。
+        if (error?.code === 'PUSH_LOCAL_MERGE_PAUSED' && await git.getInProgressOperation()) {
+          const mergedTarget = error.meta?.step === 'merge-target'
+          const rest = filterRunnable(branchTargets.slice(mergedTarget ? index + 1 : index), protectedBranches, inputOptions)
+          savePushState(context, inputOptions, currentBranch, mergedTarget ? targetBranch : null, rest, summary)
+        }
+        throw error
+      }
     }
 
     if (inputOptions.remoteMerge && remoteMergeTargets.length) {
@@ -330,7 +365,7 @@ export async function runPushWorkflow(inputOptions) {
     const operationAfterWorkflow = await git.getInProgressOperation()
     if (operationAfterWorkflow === 'merge') {
       logger.warn(`检测到未完成的 merge，已保留在当前分支 ${branchAfterWorkflow || '(unknown)'}。`)
-      logger.warn('解决冲突后执行 `icode undo --recover continue`，或执行 `icode undo --recover abort` 中止。')
+      logger.warn('解决冲突后执行 `icode continue` 接着完成剩下的步骤，或执行 `icode abort` 放弃并切回原分支。')
     } else if (branchAfterWorkflow && branchAfterWorkflow !== originalBranch) {
       try {
         await git.checkout(originalBranch)

package/src/workflows/ready-workflow.js

@@ -1,4 +1,5 @@
 import { resolveRemoteMergePlatform } from './push/remote-merge-step.js'
+import { describeOperationState, loadOperationState } from '../core/git/operation-state.js'
 import { getAiConfig } from '../core/ai/config.js'
 import { getRepoPolicy } from '../core/config/store.js'
 import { resolveGitContext } from '../core/git/context.js'
@@ -95,17 +96,19 @@ function checkCurrentBranch(currentBranch) {
  * 检查是否存在未完成的 Git 操作。
  * 输入为 operation 字符串，输出 ready 检查项。
  */
-function checkInProgressOperation(operation) {
-  if (!operation) {
+function checkInProgressOperation(operation, pausedState) {
+  const paused = describeOperationState(pausedState)
+  if (!operation && !pausedState) {
     return buildCheck('git.operation', 'pass', '没有未完成的 Git 操作', '工作区未处于 merge/rebase/cherry-pick/revert 流程中。')
   }
 
+  const detail = [operation ? `当前操作: ${operation}` : '', paused ? `被中断的 icode 命令: ${paused}` : ''].filter(Boolean).join('；')
   return buildCheck(
     'git.operation',
     'fail',
-    '存在未完成的 Git 操作',
-    `当前操作: ${operation}`,
-    `请先完成或中止 ${operation}，再继续执行 save/push。`
+    '有被中断的操作',
+    detail,
+    '解决冲突后执行 icode continue 接着完成；或执行 icode abort 放弃并切回原分支。'
   )
 }
 
@@ -249,7 +252,7 @@ export async function runReadyWorkflow(options = {}) {
 
   const checks = [
     checkCurrentBranch(currentBranch),
-    checkInProgressOperation(operation),
+    checkInProgressOperation(operation, loadOperationState(context)),
     checkChanges(changes),
     checkUpstream(upstream),
     checkAiProfile(aiConfig),

package/src/workflows/sync-workflow.js

@@ -2,6 +2,7 @@ import { IcodeError } from '../core/errors.js'
 import { ui, shortenHome } from '../core/tools/theme.js'
 import { withAutoStash } from '../core/git/autostash.js'
 import { createBackup } from '../core/git/backup.js'
+import { saveOperationState } from '../core/git/operation-state.js'
 import { resolveGitContext } from '../core/git/context.js'
 import {
   assertCleanWorktree,
@@ -136,7 +137,7 @@ export async function runSyncWorkflow(options) {
   })
 
   const summary = await withAutoStash(git, options.autostash === true, `sync ${targets.join(',')}`, () =>
-    syncBranches(git, context, targets, options, originalBranch)
+    runSyncBranches(git, context, targets, options, originalBranch)
   )
 
   return {
@@ -148,51 +149,101 @@ export async function runSyncWorkflow(options) {
   }
 }
 
-async function syncBranches(git, context, targets, options, originalBranch) {
-  const summary = []
+// 单个分支的同步步骤，冲突中断后可以从 startAt 指定的步骤接着做。
+const SYNC_STEPS = ['checkout', 'pull', 'merge-main', 'push']
+
+async function syncOneBranch(git, context, branchName, options, startAt = 'checkout') {
+  const from = SYNC_STEPS.indexOf(startAt)
+  let step = startAt
   try {
-    for (const branchName of targets) {
-      logger.info(`同步分支: ${ui.branch(branchName)}`)
+    let remoteExists = await git.branchExistsRemote(branchName)
+    if (from <= 0) {
       const setup = await ensureBranchReady(git, branchName)
-
       if (!setup.available) {
         logger.warn(`分支不存在(本地+远程): ${ui.branch(branchName)}`)
-        summary.push({
-          branch: branchName,
-          status: 'missing'
-        })
-        continue
+        return { branch: branchName, status: 'missing' }
       }
+      remoteExists = setup.remoteExists
+    }
 
-      if (setup.remoteExists) {
-        await git.pull(branchName, {
-          noRebase: !options.rebase,
-          rebase: options.rebase
-        })
-      }
+    if (from <= 1 && remoteExists) {
+      step = 'pull'
+      await git.pull(branchName, {
+        noRebase: !options.rebase,
+        rebase: options.rebase
+      })
+    }
 
-      if (options.mergeMain && branchName !== context.defaultBranch) {
-        // 把最新主分支合入目标分支，降低后续提测/发布时的冲突概率。
-        await git.merge(context.defaultBranch, {
-          noFf: true,
-          noEdit: true
-        })
-      }
+    if (from <= 2 && options.mergeMain && branchName !== context.defaultBranch) {
+      step = 'merge-main'
+      // 把最新主分支合入目标分支，降低后续提测/发布时的冲突概率。
+      await git.merge(context.defaultBranch, {
+        noFf: true,
+        noEdit: true
+      })
+    }
 
-      if (options.push) {
-        await git.push(branchName, {
-          setUpstream: !setup.remoteExists,
-          noVerify: options.noVerify
+    if (options.push) {
+      step = 'push'
+      await git.push(branchName, {
+        setUpstream: !remoteExists,
+        noVerify: options.noVerify
+      })
+    }
+  } catch (error) {
+    error.syncStep = step
+    throw error
+  }
+
+  return {
+    branch: branchName,
+    status: options.push ? 'synced-and-pushed' : 'synced'
+  }
+}
+
+/**
+ * 依次同步多个分支。某个分支发生冲突时保存进度（icode continue 接着做），并留在冲突分支上。
+ * resume = { branch, startAt } 表示从某个分支的某一步继续。
+ */
+export async function runSyncBranches(git, context, targets, options, originalBranch, resume = null) {
+  const summary = []
+  let paused = false
+  try {
+    for (let index = 0; index < targets.length; index += 1) {
+      const branchName = targets[index]
+      const startAt = resume && resume.branch === branchName ? resume.startAt : 'checkout'
+      logger.info(`同步分支: ${ui.branch(branchName)}`)
+      try {
+        summary.push(await syncOneBranch(git, context, branchName, options, startAt))
+      } catch (error) {
+        if (!(await git.getInProgressOperation())) {
+          throw error
+        }
+        // 冲突：记录剩余步骤，下一步从冲突步骤之后开始。
+        const nextStep = SYNC_STEPS[SYNC_STEPS.indexOf(error.syncStep || 'pull') + 1] || 'push'
+        saveOperationState(context, {
+          command: 'sync',
+          originalBranch,
+          currentBranch: branchName,
+          startAt: nextStep,
+          remainingTargets: targets.slice(index + 1),
+          options: {
+            push: Boolean(options.push),
+            mergeMain: Boolean(options.mergeMain),
+            rebase: Boolean(options.rebase),
+            noVerify: Boolean(options.noVerify)
+          },
+          summary
         })
+        paused = true
+        throw new IcodeError(
+          `同步 ${branchName} 时发生冲突，已停在该分支。\n解决冲突后执行 \`icode continue\` 接着同步剩下的分支，或执行 \`icode abort\` 放弃并切回 ${originalBranch}。`,
+          { code: 'SYNC_CONFLICT_PAUSED', exitCode: 2, cause: error, meta: { branch: branchName, summary } }
+        )
       }
-
-      summary.push({
-        branch: branchName,
-        status: options.push ? 'synced-and-pushed' : 'synced'
-      })
     }
   } finally {
-    if (originalBranch) {
+    if (originalBranch && !paused) {
       try {
         await git.checkout(originalBranch)
       } catch (error) {

package/src/workflows/undo-workflow.js

@@ -1,6 +1,7 @@
 import { IcodeError } from '../core/errors.js'
 import { shortenHome } from '../core/tools/theme.js'
 import { createBackup } from '../core/git/backup.js'
+import { runAbortWorkflow, runContinueWorkflow } from './continue-workflow.js'
 import { resolveGitContext } from '../core/git/context.js'
 import { GitService } from '../core/git/service.js'
 import { chooseOne, confirm } from '../core/tools/interactive.js'
@@ -82,7 +83,7 @@ async function performRollback(options) {
     } catch (error) {
       if (isRevertConflict(error)) {
         throw new IcodeError(
-          'revert 发生冲突。请解决冲突后执行 `icode undo --recover continue`，或使用 `icode undo --recover abort` 直接中止。',
+          'revert 发生冲突。解决冲突后执行 `icode continue`，或执行 `icode abort` 直接中止。',
           {
             code: 'REVERT_CONFLICT',
             cause: error,
@@ -140,30 +141,7 @@ async function performRollback(options) {
   }
 }
 
-// 按操作类型调用对应的 continue / abort。
-async function continueOperation(git, operation) {
-  if (operation === 'revert') {
-    await git.revertContinue()
-  } else if (operation === 'merge') {
-    await git.mergeContinue()
-  } else if (operation === 'rebase') {
-    await git.rebaseContinue()
-  } else {
-    await git.cherryPickContinue()
-  }
-}
 
-async function abortOperation(git, operation) {
-  if (operation === 'revert') {
-    await git.revertAbort()
-  } else if (operation === 'merge') {
-    await git.mergeAbort()
-  } else if (operation === 'rebase') {
-    await git.rebaseAbort()
-  } else {
-    await git.abortCherryPick()
-  }
-}
 
 // 解析交互菜单选择，输入菜单 value，输出 mode/ref 或 canceled。
 function parseSelection(selection) {
@@ -295,31 +273,21 @@ async function resolvePendingOperation(options) {
     }
   }
 
+  // 与 icode continue / icode abort 走同一套流程：自动暂存已解决文件，并续做被打断的 push/migrate/sync。
   if (action === 'continue') {
-    try {
-      await continueOperation(git, pending)
-
-      return {
-        resolvedOperation: pending,
-        recoverAction: 'continue'
-      }
-    } catch (error) {
-      throw new IcodeError(
-        `${pending} --continue 失败，请先解决冲突后重试，或使用 --recover abort。`,
-        {
-          code: 'UNDO_CONTINUE_FAILED',
-          cause: error,
-          meta: error.meta
-        }
-      )
+    const result = await runContinueWorkflow({ cwd: options.cwd, repoMode: options.repoMode })
+    return {
+      resolvedOperation: pending,
+      recoverAction: 'continue',
+      ...(result.resumed ? { resumed: result.resumed, summary: result.summary } : {})
     }
   }
 
-  await abortOperation(git, pending)
-
+  const result = await runAbortWorkflow({ cwd: options.cwd, repoMode: options.repoMode })
   return {
     resolvedOperation: pending,
-    recoverAction: 'abort'
+    recoverAction: 'abort',
+    ...(result.aborted ? { aborted: result.aborted, returnedTo: result.returnedTo } : {})
   }
 }