@icode-js/icode 3.2.0 → 3.4.0

package/src/workflows/push-workflow.js

@@ -1,6 +1,8 @@
-import { formatAiCommitSummary } from '../core/ai/commit-summary.js'
-import { getPlatformConfig, getRepoPolicy } from '../core/config/store.js'
+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,
@@ -8,448 +10,134 @@ import {
   readGitSafetyState
 } from '../core/git/preconditions.js'
 import { GitService } from '../core/git/service.js'
-import { confirm, input } from '../core/tools/interactive.js'
-import { requestRemoteMerge, resolveRemoteMergeProjectUrl } from '../core/remote-merge/client.js'
+import { chooseMany, chooseOne, confirm, isInteractiveTerminal } from '../core/tools/interactive.js'
 import { logger } from '../core/tools/logger.js'
-import { runAiCommitWorkflow } from './ai-commit-workflow.js'
+import { prepareAiCommitIfEnabled, prepareCommitIfNeeded } from './push/commit-step.js'
+import { buildLocalMergePauseError, mergeIntoTargetAndPush, pushCurrentBranch } from './push/local-merge-step.js'
+import { buildPushDryRunPlan } from './push/plan.js'
+import {
+  buildRemoteMergeBatchPauseError,
+  normalizeRemoteMergePolicy,
+  resolveRemoteMergePlatform,
+  runConcurrentRemoteMerges
+} from './push/remote-merge-step.js'
+
+// push 只负责编排：提交 -> 同步主分支 -> 逐个处理目标分支（推送当前 / 本地 merge / 远程合并）。
+// 各阶段的具体实现见 ./push/ 目录。
 
 function uniqueBranches(branches) {
   return [...new Set(branches.map((item) => item.trim()).filter(Boolean))]
 }
 
-// 基于 commit 内容构建远程 MR 标题与正文，确保标题和内容都来自真实提交信息。
-async function buildRemoteMergeCommitContent(git, sourceBranch, targetBranch) {
-  const rangeSpec = `origin/${targetBranch}..${sourceBranch}`
-  let commits = await git.listCommitMessages(rangeSpec)
+// 合并配置里的受保护分支：全局配置 + 仓库 .icoderc。
+function resolveProtectedBranches(policy, context) {
+  return new Set(
+    [...(policy.protectedBranches || []), ...(context.repoConfig?.protectedBranches || [])]
+      .map((item) => String(item).trim())
+      .filter(Boolean)
+  )
+}
 
-  if (!commits.length) {
-    const latestCommit = await git.getCommitMessage(sourceBranch)
-    if (latestCommit) {
-      commits = [latestCommit]
-    }
+/**
+ * 强推只允许作用在当前分支，并拒绝主分支和受保护分支（除非 --force-protected）。
+ */
+function validateForcePush(inputOptions, branchTargets, currentBranch, context, protectedBranches) {
+  if (!inputOptions.force) {
+    return
   }
 
-  if (!commits.length) {
-    throw new IcodeError(`无法读取远程合并提交内容: ${sourceBranch} -> ${targetBranch}`, {
-      code: 'PUSH_REMOTE_MERGE_COMMIT_CONTENT_EMPTY',
+  if (inputOptions.remoteMerge || branchTargets.some((branch) => branch !== currentBranch)) {
+    throw new IcodeError('--force 只能用于推送当前分支，不能和目标分支或远程合并一起使用。', {
+      code: 'PUSH_FORCE_SCOPE_INVALID',
       exitCode: 2
     })
   }
 
-  const latestCommit = commits[commits.length - 1]
-  const description = commits
-    .map((commit) => {
-      if (commit.body) {
-        return `${commit.subject}\n\n${commit.body}`
-      }
-      return commit.subject
-    })
-    .join('\n\n')
-
-  return {
-    title: latestCommit.subject,
-    description
-  }
-}
-
-// 提取远程合并失败原因，优先使用 IcodeError.meta，其次回退到 error.message。
-function resolveRemoteMergeFailureReason(error) {
-  const metaStep = typeof error?.meta?.step === 'string' ? error.meta.step.trim() : ''
-  const metaReason = typeof error?.meta?.reason === 'string' ? error.meta.reason.trim() : ''
-  if (metaReason) {
-    return metaStep ? `${metaReason} [step=${metaStep}]` : metaReason
-  }
-
-  const message = typeof error?.message === 'string' ? error.message.trim() : ''
-  return message || '远程合并失败'
-}
-
-// Run AI commit before push and keep the full generated message in follow-up logs.
-async function prepareAiCommitIfEnabled(inputOptions) {
-  if (!inputOptions.aiCommit) {
-    return {
-      enabled: false
-    }
-  }
-
-  if (inputOptions.message?.trim()) {
-    logger.warn('--ai-commit 已启用，将优先使用 AI 生成的提交信息。')
-  }
-
-  try {
-    const result = await runAiCommitWorkflow({
-      apply: true,
-      lang: inputOptions.aiCommitLang || 'zh',
-      profile: inputOptions.aiProfile,
-      repoMode: inputOptions.repoMode,
-      noVerify: inputOptions.noVerify,
-      yes: inputOptions.yes,
-      cwd: inputOptions.cwd,
-      silentContextLog: true
+  if (!branchTargets.includes(currentBranch)) {
+    throw new IcodeError('--force 需要推送当前分支，不能和 --not-push-current 一起使用。', {
+      code: 'PUSH_FORCE_SCOPE_INVALID',
+      exitCode: 2
     })
-
-    if (result.canceled) {
-      logger.warn('已取消 AI 自动提交。')
-      return {
-        enabled: true,
-        canceled: true
-      }
-    }
-
-    logger.success(`AI 自动提交完成:\n${formatAiCommitSummary(result.commitId, result.commitMessage)}`)
-    return {
-      enabled: true,
-      applied: true,
-      commitId: result.commitId,
-      commitMessage: result.commitMessage
-    }
-  } catch (error) {
-    if (error?.code === 'AI_COMMIT_EMPTY_DIFF') {
-      logger.info('未检测到可提交改动，跳过 --ai-commit。')
-      return {
-        enabled: true,
-        skipped: true,
-        reason: 'no-diff'
-      }
-    }
-
-    throw error
-  }
-}
-
-// 在 push 场景下按需创建本地提交，输入 GitService、命令参数和已读取的改动摘要，输出是否提交。
-async function prepareCommitIfNeeded(git, options, changes) {
-  if (changes.clean) {
-    logger.info('工作区无改动，跳过 commit。')
-    return false
   }
 
-  let message = options.message?.trim()
-  if (!message) {
-    message = (await input('请输入提交信息', '')).trim()
-  }
-
-  if (!message) {
-    throw new IcodeError('检测到代码改动但未提供提交信息，请使用 -m 或 --message。', {
-      code: 'PUSH_COMMIT_MESSAGE_REQUIRED',
+  const isGuarded = currentBranch === context.defaultBranch || protectedBranches.has(currentBranch)
+  if (isGuarded && !inputOptions.forceProtected) {
+    throw new IcodeError(`拒绝强推主分支/受保护分支: ${currentBranch}。确有必要请加 --force-protected。`, {
+      code: 'PUSH_FORCE_PROTECTED',
       exitCode: 2
     })
   }
-
-  // 统一自动暂存，降低同学手动 add 的负担。
-  await git.stageAll()
-  await git.commit(message, {
-    noVerify: options.noVerify
-  })
-  logger.success(`提交完成: ${message}`)
-  return true
-}
-
-// 提取底层 Git 失败细节，输入异常对象，输出用于暂停错误的简洁原因。
-function resolveGitFailureReason(error) {
-  const stderr = typeof error?.meta?.stderr === 'string' ? error.meta.stderr.trim() : ''
-  const stdout = typeof error?.meta?.stdout === 'string' ? error.meta.stdout.trim() : ''
-  const output = [stderr, stdout].filter(Boolean).join('\n').trim()
-  const message = typeof error?.message === 'string' ? error.message.trim() : ''
-  const reason = output || message || 'Git 操作失败'
-
-  return reason.length > 2000 ? `${reason.slice(0, 2000)}...` : reason
-}
-
-// 判断 Git 失败是否来自合并冲突，输入异常对象，输出布尔结果。
-function isGitConflictFailure(error) {
-  const text = [
-    error?.meta?.stderr || '',
-    error?.meta?.stdout || '',
-    error?.message || ''
-  ].join('\n')
-
-  return /CONFLICT \(|Automatic merge failed|fix conflicts|unmerged files|needs merge|you need to resolve your current index first/i.test(text)
-}
-
-// 构建本地合并暂停错误，输入分支、阶段和原始异常，输出可被命令层汇总的 IcodeError。
-function buildLocalMergePauseError({ sourceBranch, targetBranch, step, error, summary = [] }) {
-  const reason = resolveGitFailureReason(error)
-  const conflict = isGitConflictFailure(error)
-  const prefix = conflict ? '本地合并冲突' : '本地合并失败'
-  const nextStep = conflict
-    ? '请解决冲突后执行 `icode undo --recover continue`，或执行 `icode undo --recover abort` 中止本次合并。'
-    : '请根据上面的 Git 错误修复后重试。'
-
-  return new IcodeError(`${prefix}(${step}): ${sourceBranch} -> ${targetBranch}\n${reason}\n${nextStep}`, {
-    code: 'PUSH_LOCAL_MERGE_PAUSED',
-    exitCode: 2,
-    cause: error,
-    meta: {
-      sourceBranch,
-      targetBranch,
-      step,
-      reason,
-      summary
-    }
-  })
-}
-
-async function checkoutTargetBranch(git, targetBranch, sourceBranch, summary = []) {
-  const localExists = await git.branchExistsLocal(targetBranch)
-  const remoteExists = await git.branchExistsRemote(targetBranch)
-  let checkoutMode = 'local'
-
-  if (localExists) {
-    await git.checkout(targetBranch)
-  } else if (remoteExists) {
-    await git.checkoutTracking(targetBranch)
-    checkoutMode = 'tracking'
-  } else {
-    // 目标分支不存在时，默认从 source 分支切出，方便“临时发布分支”场景。
-    logger.warn(`目标分支 ${targetBranch} 不存在，将从 ${sourceBranch} 创建。`)
-    await git.checkoutNewBranch(targetBranch, sourceBranch)
-    checkoutMode = 'created'
-  }
-
-  if (remoteExists) {
-    try {
-      await git.pull(targetBranch, {
-        noRebase: true
-      })
-    } catch (error) {
-      throw buildLocalMergePauseError({
-        sourceBranch,
-        targetBranch,
-        step: 'pull-target',
-        error,
-        summary
-      })
-    }
-  }
-
-  return {
-    remoteExists,
-    checkoutMode
-  }
 }
 
-function normalizeRemoteMergePolicy(policy = {}) {
-  const remoteMerge = policy.remoteMerge && typeof policy.remoteMerge === 'object' ? policy.remoteMerge : {}
-  return {
-    enabled: remoteMerge.enabled !== false
-  }
+// 去掉会被跳过的受保护分支，只保留续做时真正要处理的分支。
+function filterRunnable(branches, protectedBranches, inputOptions) {
+  return branches.filter((branch) => !(protectedBranches.has(branch) && !inputOptions.forceProtected))
 }
 
-// 归一化平台级远程合并配置，避免命令层拿到带空白的原始值。
-function normalizeRemoteMergePlatformConfig(config = {}) {
-  return {
-    provider: typeof config.provider === 'string' ? config.provider.trim() : '',
-    apiKey: typeof config.apiKey === 'string' ? config.apiKey.trim() : ''
-  }
-}
-
-function buildRemoteMergePauseError(targetBranch, reason, meta = {}) {
-  return new IcodeError(`远程合并已暂停(${targetBranch}): ${reason}`, {
-    code: 'PUSH_REMOTE_MERGE_PAUSED',
-    exitCode: 2,
-    meta: {
-      targetBranch,
-      reason,
-      ...meta
-    }
-  })
-}
-
-// 统一把 provider 返回的 step 注入错误文案，便于定位 create/merge/inspect 具体失败点。
-function buildRemoteMergeResultMessage(prefix, result) {
-  const reason = typeof result?.reason === 'string' && result.reason.trim()
-    ? result.reason.trim()
-    : '未知原因'
-  const step = typeof result?.step === 'string' && result.step.trim()
-    ? result.step.trim()
-    : ''
-
-  return step ? `${prefix}(${step}): ${reason}` : `${prefix}: ${reason}`
-}
-
-// 构建批量远程合并暂停错误，明确指出具体失败分支与原因。
-function buildRemoteMergeBatchPauseError(failures, summary) {
-  const branchesLabel = failures.map((item) => item.branch).join(', ')
-  const detail = failures.map((item) => `${item.branch}: ${item.reason}`).join(' | ')
-
-  return new IcodeError(`远程合并已暂停(${branchesLabel}): ${detail}`, {
-    code: 'PUSH_REMOTE_MERGE_PAUSED',
-    exitCode: 2,
-    meta: {
-      failures,
-      summary
-    }
+// 保存 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()
   })
 }
 
-// 构建 push dry-run 步骤，输入分支目标和策略，输出不会产生副作用的计划列表。
-function buildPushDryRunPlan({ currentBranch, branchTargets, protectedBranches, inputOptions }) {
-  const steps = []
-
-  if (inputOptions.aiCommit) {
-    steps.push({
-      action: 'ai-commit',
-      branch: currentBranch,
-      reason: '将生成并提交 AI commit'
-    })
-  } else {
-    steps.push({
-      action: 'commit-if-needed',
-      branch: currentBranch,
-      reason: inputOptions.message ? '检测到改动时使用 -m/--message 提交' : '检测到改动时会要求输入提交信息'
-    })
-  }
-
-  if (inputOptions.pullMain) {
-    steps.push({
-      action: 'pull-main',
-      branch: currentBranch,
-      reason: '将主分支同步到当前分支'
-    })
-  }
-
-  branchTargets.forEach((targetBranch) => {
-    if (protectedBranches.has(targetBranch) && !inputOptions.forceProtected) {
-      steps.push({
-        action: 'skip-protected',
-        branch: targetBranch,
-        reason: '受保护分支，未传 --force-protected'
-      })
-      return
-    }
-
-    if (targetBranch === currentBranch) {
-      steps.push({
-        action: 'push-current',
-        branch: targetBranch,
-        reason: '将同步并推送当前分支'
-      })
-      return
-    }
-
-    steps.push({
-      action: inputOptions.remoteMerge ? 'remote-merge' : 'local-merge',
-      branch: targetBranch,
-      reason: inputOptions.remoteMerge ? '将创建并合并远程 MR' : '将切换目标分支、本地 merge 后推送'
-    })
+/**
+ * 交互选择推送目标：只推当前分支（默认）/ 同时本地合并到其他分支 / 通过 PR 合并。
+ * 输出 { targets, remoteMerge } 或 null（取消）。
+ */
+async function pickPushTargets(git, currentBranch, context, protectedBranches) {
+  const unpushed = await git.countCommits(`${git.remoteRef(currentBranch)}..HEAD`)
+  const hint = (await git.refExists(git.remoteRef(currentBranch)))
+    ? (unpushed ? `${unpushed} 个提交待推送` : '远程已是最新')
+    : '远程还没有这个分支'
+  const mode = await chooseOne(`推送 ${ui.branch(currentBranch)}`, [
+    { value: 'current', label: `只推送 ${currentBranch}`, hint },
+    { value: 'local', label: '同时合并到其他分支（本地 merge）', hint: '例如 test / release' },
+    { value: 'remote', label: '同时通过 PR/MR 合并到其他分支（远程合并）' },
+    { value: 'cancel', label: '取消' }
+  ], 0, { filter: false })
+
+  if (mode === 'cancel') {
+    return null
+  }
+  if (mode === 'current') {
+    return { targets: [currentBranch], remoteMerge: false }
+  }
+
+  const names = [...new Set([...(await git.listLocalBranches()), ...(await git.listRemoteBranches())])]
+    .filter((name) => name && name !== currentBranch)
+  if (!names.length) {
+    logger.warn('没有其它分支可选，只推送当前分支。')
+    return { targets: [currentBranch], remoteMerge: false }
+  }
+  // 常见的部署分支排在前面。
+  const priority = ['test', 'dev', 'develop', 'staging', 'pre', 'uat', 'release', context.defaultBranch]
+  names.sort((a, b) => {
+    const pa = priority.indexOf(a) === -1 ? 99 : priority.indexOf(a)
+    const pb = priority.indexOf(b) === -1 ? 99 : priority.indexOf(b)
+    return pa - pb || a.localeCompare(b)
   })
 
-  return {
-    currentBranch,
-    branchTargets,
-    remoteMerge: Boolean(inputOptions.remoteMerge),
-    steps
-  }
-}
+  const picked = await chooseMany('选择要合并到的分支', names.map((name) => ({
+    value: name,
+    label: name,
+    hint: protectedBranches.has(name) ? '受保护，会被跳过（--force-protected 可覆盖）' : ''
+  })), { minSelections: 1, doneLabel: '开始推送' })
 
-// 根据 origin 推导远程合并项目 URL，输入平台配置与 remote，输出项目 URL。
-function resolveRemoteMergeProjectUrlFromOrigin(remoteMergePlatform, remoteOriginUrl) {
-  return {
-    projectUrl: resolveRemoteMergeProjectUrl({
-      provider: remoteMergePlatform.provider,
-      remoteUrl: remoteOriginUrl
-    }),
-    source: 'origin'
+  if (!picked) {
+    return null
   }
-}
-
-// 基于 origin 推导 GitLab 项目地址并发起固定 API 的 MR 创建请求。
-async function performRemoteMerge({ git, currentBranch, targetBranch, remoteExists, inputOptions, remoteMergePolicy, remoteMergePlatform }) {
-  if (!remoteExists) {
-    throw buildRemoteMergePauseError(targetBranch, '远程合并要求目标分支已存在于 origin。', {
-      remoteExists: false
-    })
-  }
-
-  if (!remoteMergePolicy.enabled) {
-    throw buildRemoteMergePauseError(targetBranch, '仓库未启用远程合并配置，请先配置 repositories.<repo>.remoteMerge.enabled=true。')
-  }
-
-  if (!remoteMergePlatform.apiKey) {
-    throw buildRemoteMergePauseError(targetBranch, '平台未配置远程合并密钥，请先执行 icode config platform remote-merge set --provider <name> --api-key <key>。')
-  }
-
-  const remoteOriginUrl = await git.getRemoteUrl('origin')
-  const { projectUrl, source } = resolveRemoteMergeProjectUrlFromOrigin(remoteMergePlatform, remoteOriginUrl)
-  if (!projectUrl) {
-    throw buildRemoteMergePauseError(targetBranch, '无法从 origin 自动识别 GitLab 项目 URL，请检查 origin 是否指向 GitLab 仓库。', {
-      origin: remoteOriginUrl
-    })
-  }
-  logger.info(`GitLab 项目 URL(${source}): ${logger.color('green', projectUrl)}`)
-
-  logger.info(`发起远程合并: ${logger.color('yellow', currentBranch)} -> ${logger.color('yellow', targetBranch)}`)
-  const mergeRequestContent = await buildRemoteMergeCommitContent(git, currentBranch, targetBranch)
-  const result = await requestRemoteMerge({
-    provider: remoteMergePlatform.provider,
-    apiKey: remoteMergePlatform.apiKey,
-    projectUrl,
-    sourceBranch: currentBranch,
-    targetBranch,
-    mergeRequestTitle: mergeRequestContent.title,
-    mergeRequestDescription: mergeRequestContent.description,
-    repoRoot: git.cwd,
-    noVerify: inputOptions.noVerify
-  })
-
-  if (result.conflict) {
-    throw buildRemoteMergePauseError(targetBranch, buildRemoteMergeResultMessage('远程合并冲突', result), {
-      sourceBranch: currentBranch,
-      step: result.step || '',
-      result
-    })
-  }
-
-  if (!result.ok) {
-    throw buildRemoteMergePauseError(targetBranch, buildRemoteMergeResultMessage('远程合并失败', result), {
-      sourceBranch: currentBranch,
-      step: result.step || '',
-      result
-    })
-  }
-
-  const successReason = typeof result.reason === 'string' && result.reason.trim()
-    ? result.reason.trim()
-    : '远程合并已完成'
-
-  if (result.mergeRequestUrl) {
-    logger.success(`${successReason}: ${logger.color('green', result.mergeRequestUrl)}`)
-  } else {
-    logger.success(`${successReason}: ${logger.color('yellow', currentBranch)} -> ${logger.color('yellow', targetBranch)}`)
-  }
-
-  return result
-}
-
-// 并发执行多个远程合并目标分支，并把冲突/失败精确归档到对应分支。
-async function runConcurrentRemoteMerges(options) {
-  const tasks = options.targetBranches.map(async (targetBranch) => {
-    try {
-      logger.info(`处理分支: ${targetBranch}`)
-      const remoteExists = await options.git.branchExistsRemote(targetBranch)
-      const remoteMergeResult = await performRemoteMerge({
-        ...options,
-        targetBranch,
-        remoteExists
-      })
-
-      return {
-        branch: targetBranch,
-        status: 'remote-merged-and-pushed',
-        mergeRequestUrl: remoteMergeResult.mergeRequestUrl || '',
-        mergeRequestId: remoteMergeResult.mergeRequestId || ''
-      }
-    } catch (error) {
-      return {
-        branch: targetBranch,
-        status: 'paused',
-        reason: resolveRemoteMergeFailureReason(error)
-      }
-    }
-  })
-
-  return Promise.all(tasks)
+  return { targets: [currentBranch, ...picked], remoteMerge: mode === 'remote' }
 }
 
 /**
@@ -457,18 +145,20 @@ async function runConcurrentRemoteMerges(options) {
  * 输入为 push 命令选项，输出推送/合并摘要；关键假设是实际执行前必须没有未完成操作和冲突文件。
  */
 export async function runPushWorkflow(inputOptions) {
+  // 交互选择可能切换到远程合并，这里复制一份，避免修改调用方传入的对象。
+  inputOptions = { ...inputOptions }
   const context = await resolveGitContext({
     cwd: inputOptions.cwd,
-    repoMode: inputOptions.repoMode
+    repoMode: inputOptions.repoMode,
+    remote: inputOptions.remote
   })
 
   const git = new GitService(context)
   const policy = getRepoPolicy(context.topLevelPath)
-  const protectedBranches = new Set((policy.protectedBranches || []).map((item) => item.trim()).filter(Boolean))
+  const protectedBranches = resolveProtectedBranches(policy, context)
   const remoteMergePolicy = normalizeRemoteMergePolicy(policy)
-  const remoteMergePlatform = normalizeRemoteMergePlatformConfig(getPlatformConfig('remoteMerge'))
 
-  logger.info(`仓库根目录: ${context.topLevelPath}`)
+  logger.hint(`仓库 ${shortenHome(context.topLevelPath)}`)
   if (context.inheritedFromParent) {
     logger.warn('当前目录继承了父级 Git 仓库，命令将基于父仓库根目录执行。')
   }
@@ -496,17 +186,21 @@ export async function runPushWorkflow(inputOptions) {
     })
   }
 
+  validateForcePush(inputOptions, branchTargets, currentBranch, context, protectedBranches)
+
   if (inputOptions.dryRun) {
     return {
       dryRun: true,
       repoRoot: context.topLevelPath,
       currentBranch,
+      remote: git.remote,
       inheritedFromParent: context.inheritedFromParent,
       plan: buildPushDryRunPlan({
         currentBranch,
         branchTargets,
         protectedBranches,
-        inputOptions
+        inputOptions,
+        remote: git.remote
       })
     }
   }
@@ -515,7 +209,7 @@ export async function runPushWorkflow(inputOptions) {
   assertNoPendingOperation(safetyState.operation, 'push', 'PUSH_GIT_OPERATION_IN_PROGRESS')
   assertNoConflictedFiles(safetyState.changes, 'push', 'PUSH_CONFLICTED_FILES')
 
-  const aiCommitResult = await prepareAiCommitIfEnabled(inputOptions)
+  const aiCommitResult = await prepareAiCommitIfEnabled(git, context, inputOptions, safetyState.changes)
   if (aiCommitResult.canceled) {
     return {
       canceled: true,
@@ -528,33 +222,60 @@ export async function runPushWorkflow(inputOptions) {
 
   const shouldRunManualCommit = !aiCommitResult.applied && aiCommitResult.reason !== 'no-diff'
   if (shouldRunManualCommit) {
-    await prepareCommitIfNeeded(git, inputOptions, safetyState.changes)
+    await prepareCommitIfNeeded(git, context, inputOptions, safetyState.changes)
   }
+
+  // 强推的 lease 基准必须是 fetch 之前看到的远程 sha，否则 fetch 后 lease 形同虚设。
+  const expectedRemoteSha = inputOptions.force ? await git.getRemoteBranchSha(currentBranch) : ''
   await git.fetch()
 
   const summary = []
 
   if (inputOptions.pullMain && context.defaultBranch !== currentBranch) {
-    logger.info(`先同步主分支 ${context.defaultBranch} 到当前分支 ${currentBranch}`)
+    logger.info(`先同步主分支 ${ui.branch(context.defaultBranch)} 到当前分支 ${ui.branch(currentBranch)}`)
     try {
       await git.pull(context.defaultBranch, {
         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
     }
   }
 
-  if (!inputOptions.yes) {
+  // 交互终端里没写目标分支时，用选择代替手输分支名；这一步的选择本身就是确认。
+  let confirmedByPicker = false
+  if (!inputOptions.yes && !inputOptions.force && !inputOptions.remoteMerge && !(inputOptions.targetBranches || []).length && !inputOptions.notPushCurrent && isInteractiveTerminal()) {
+    const picked = await pickPushTargets(git, currentBranch, context, protectedBranches)
+    if (!picked) {
+      logger.warn('已取消执行。')
+      return {
+        canceled: true,
+        branchTargets,
+        repoRoot: context.topLevelPath
+      }
+    }
+    branchTargets = picked.targets
+    if (picked.remoteMerge) {
+      inputOptions = { ...inputOptions, remoteMerge: true }
+    }
+    confirmedByPicker = true
+  }
+
+  if (!inputOptions.yes && !confirmedByPicker) {
+    const action = inputOptions.force ? '强推(--force-with-lease)' : '推送/合并'
     const confirmed = await confirm(
-      `确认将 ${currentBranch} 推送/合并到以下分支: ${branchTargets.join(', ')} ?`,
-      true
+      `确认将 ${currentBranch} ${action}到以下分支: ${branchTargets.join(', ')} ?`,
+      !inputOptions.force
     )
 
     if (!confirmed) {
@@ -567,82 +288,52 @@ export async function runPushWorkflow(inputOptions) {
     }
   }
 
+  // 本地 merge 会改动目标分支，强推会覆盖远程分支：执行前先记录恢复点。
+  const localMergeTargets = inputOptions.remoteMerge ? [] : branchTargets.filter((branch) => branch !== currentBranch)
+  const backupBranches = []
+  for (const branch of [currentBranch, ...localMergeTargets]) {
+    if (await git.branchExistsLocal(branch)) {
+      backupBranches.push(branch)
+    }
+  }
+  const backup = (localMergeTargets.length || inputOptions.force)
+    ? await createBackup(git, {
+      reason: inputOptions.force ? `push --force ${currentBranch}` : `push ${currentBranch} -> ${localMergeTargets.join(',')}`,
+      branches: backupBranches,
+      remoteBranches: inputOptions.force ? [currentBranch] : []
+    })
+    : null
+
   const originalBranch = currentBranch
   const remoteMergeTargets = []
+  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(`跳过受保护分支: ${targetBranch}（可用 --force-protected 覆盖）`)
+        logger.warn(`跳过受保护分支: ${ui.branch(targetBranch)}（可用 --force-protected 覆盖）`)
         summary.push({ branch: targetBranch, status: 'skipped-protected' })
         continue
       }
 
-      if (targetBranch === currentBranch) {
-        logger.info(`处理分支: ${targetBranch}`)
-        const remoteExists = await git.branchExistsRemote(targetBranch)
-        if (remoteExists) {
-          logger.info(`同步远程分支: ${targetBranch}`)
-          try {
-            await git.pull(targetBranch, {
-              noRebase: true
-            })
-          } catch (error) {
-            throw buildLocalMergePauseError({
-              sourceBranch: `origin/${targetBranch}`,
-              targetBranch,
-              step: 'pull-current',
-              error,
-              summary
-            })
-          }
-        }
-
-        logger.info(`推送当前分支: ${targetBranch}`)
-        await git.push(targetBranch, {
-          setUpstream: !remoteExists,
-          noVerify: inputOptions.noVerify
-        })
-
-        logger.success(`推送成功: ${targetBranch}`)
-        summary.push({ branch: targetBranch, status: 'pushed' })
+      if (inputOptions.remoteMerge && targetBranch !== currentBranch) {
+        remoteMergeTargets.push(targetBranch)
         continue
       }
 
-      if (inputOptions.remoteMerge) {
-        remoteMergeTargets.push(targetBranch)
-      } else {
-        logger.info(`处理分支: ${targetBranch}`)
-        logger.info(`切换到目标分支: ${targetBranch}`)
-        const { remoteExists, checkoutMode } = await checkoutTargetBranch(git, targetBranch, currentBranch, summary)
-        logger.info(`目标分支准备完成: ${targetBranch} (${checkoutMode})`)
-
-        // 保留 merge commit，方便后续追溯“从哪个分支合并过来”。
-        logger.info(`合并分支: ${currentBranch} -> ${targetBranch}`)
-        try {
-          await git.merge(currentBranch, {
-            noFf: true,
-            noEdit: true
-          })
-        } catch (error) {
-          throw buildLocalMergePauseError({
-            sourceBranch: currentBranch,
-            targetBranch,
-            step: 'merge-target',
-            error,
-            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)
         }
-        logger.success(`合并成功: ${currentBranch} -> ${targetBranch}`)
-
-        logger.info(`推送目标分支: ${targetBranch}`)
-        await git.push(targetBranch, {
-          setUpstream: !remoteExists,
-          noVerify: inputOptions.noVerify
-        })
-
-        logger.success(`目标分支推送成功: ${targetBranch}`)
-        summary.push({ branch: targetBranch, status: 'merged-and-pushed' })
+        throw error
       }
     }
 
@@ -654,7 +345,7 @@ export async function runPushWorkflow(inputOptions) {
         targetBranches: remoteMergeTargets,
         inputOptions,
         remoteMergePolicy,
-        remoteMergePlatform
+        remoteMergePlatform: await resolveRemoteMergePlatform(git)
       })
       summary.push(...remoteMergeSummary)
 
@@ -674,12 +365,12 @@ 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)
       } catch (error) {
-        logger.warn(`未能自动切回原分支 ${originalBranch}: ${error.message}`)
+        logger.warn(`未能自动切回原分支 ${ui.branch(originalBranch)}: ${error.message}`)
       }
     }
   }
@@ -687,6 +378,8 @@ export async function runPushWorkflow(inputOptions) {
   return {
     repoRoot: context.topLevelPath,
     currentBranch,
+    remote: git.remote,
+    backupId: backup?.entries.length ? backup.id : '',
     summary,
     inheritedFromParent: context.inheritedFromParent
   }