@jspg-ai/coding-bb 0.0.4 → 0.0.5-beta.1

package/cbb/worktrees/skills/cbb-worktree-close/scripts/merge-branches.js

@@ -14,19 +14,29 @@ require('./silence-popup');
  *   node merge-branches.js <ws_root> <branch> [--apps a,b] [--target <分支>] --check   # 仅判定，不合并
  *
  * 目标分支：
- *   缺省 / --target 等于该仓库探测主干 → 主干快路径（本地主干检出上 merge --no-ff → push）
- *   --target 指定非主干分支            → 临时 worktree（基于 origin/<target>，不动用户检出）
+ *   缺省 / --target 等于该仓库探测主干 → 主干快路径（本地主干检出上 merge --no-ff → push；
+ *                                        检出未提交改动 autostash 让路，交付后自动恢复）
+ *   --target 指定非主干分支：目标 == 当前检出 → 就地合并（同主干快路径处理）
+ *                                        否则 → 临时 worktree（基于 origin/<target>，不动用户检出）
  *
  * 模式：
  *   --check      逐仓库判定是否已合并到目标（主干含 release-* 中转 / squash / cherry-pick 兜底，
  *                算法与 cbb-worktree-close 的 safety-check.js 同源）；不修改任何状态
  *   默认         两阶段（ADR 0007）：
- *                  1. 预检：逐仓库校验（目标可解析 / 检出干净 / 分支存在）
+ *                  1. 预检：逐仓库校验（目标可解析 / 分支存在 / 主干不领先 origin）；
+ *                     检出上未提交改动（含未跟踪）不再拦截——执行阶段自动暂存让路（autostash）
  *                     任一不过 → 退出 2，不执行任何合并
- *                  2. 执行：merge --no-ff → push；执行中失败 → 停止并报告已完成清单（不回滚；重跑幂等）
+ *                  2. 执行：autostash（如有）→ checkout 目标 → pull --ff-only → merge --no-ff
+ *                     → push → 自动恢复暂存；执行中失败 → 先恢复暂存再停止并报告已完成清单
+ *                     （不回滚；重跑幂等）。恢复冲突时保留 stash 条目交用户决策
+ *                     （"后提交者解决"：暂存侧改动适配已交付主干，agent 代解或用户手动二选一）
  *   --dry-run    只做预检，不执行
  *
- * 退出码：0 全部成功（含 skipped / merged）/ 1 参数错误 / 2 预检或执行失败（含 need-mr / unmerged）
+ * 恢复机制取舍：先 pop --index（还原 staged 分区）；若其失败且有冲突，reset --hard 回到
+ *   本次合并的 HEAD 后 plain apply 一次——保证冲突只"单次应用"落盘（双重应用风险为零），
+ *   代价是冲突场景下 staged/unstaged 分区扁平化（内容无损）。ignored 文件不参与暂存。
+ * 退出码：0 全部成功（含 skipped / merged）/ 1 参数错误 / 2 预检或执行失败（含 need-mr /
+ *   unmerged / autostashPending——交付已完成，只是暂存未恢复，按 AUTOSTASH_PENDING 行处理）
  * 末行：MERGE_RESULT [...] 或 MERGE_CHECK_RESULT [...]
  */
 
@@ -141,6 +151,101 @@ function cleanupTempWorktree(repoPath, tmpDir) {
   run('git worktree prune', repoPath);
 }
 
+// ── autostash 让路 / 恢复（检出上的未提交改动不阻断直合并，ADR 0008 扩展） ──
+
+/** 统计检出上未提交项（含未跟踪），仅用于预检输出注记；-1 = 状态不可读 */
+function countUncommitted(workPath) {
+  const s = run('git status --porcelain', workPath);
+  if (!s.ok) return -1;
+  return s.out ? s.out.split(/\r?\n/).filter(Boolean).length : 0;
+}
+
+/**
+ * 暂存检出上的未提交改动（含未跟踪，不含 ignored），为合并让路。
+ * 经 refs/stash 前后对比判断是否真的建了条目（无改动时 stash 不建条目）。
+ * 返回 { ok, created, oid, stashId } 或 { ok: false, err }
+ */
+function autostashPush(workPath, tag) {
+  const before = run('git rev-parse -q --verify "refs/stash"', workPath);
+  const stamp = new Date().toISOString().slice(0, 19).replace('T', ' ');
+  const msg = 'cbb-autostash ' + tag + ' [' + stamp + ']';
+  const push = run('git stash push --include-untracked -m "' + msg + '"', workPath);
+  if (!push.ok) return { ok: false, err: (push.err || push.out || 'stash push 失败').split(/\r?\n/)[0] };
+  const after = run('git rev-parse -q --verify "refs/stash"', workPath);
+  const oid = after.out || '';
+  return { ok: true, created: !!oid && oid !== (before.out || ''), oid, stashId: msg };
+}
+
+function conflictedPaths(workPath) {
+  const d = run('git diff --name-only --diff-filter=U', workPath);
+  return d.ok && d.out ? d.out.split(/\r?\n/).filter(Boolean) : [];
+}
+
+/**
+ * 单次恢复尝试 + 分类。返回：
+ *   { done }            完全恢复（pop 成功，或 apply 完整成功 + drop 成功）
+ *   { conflicted }      冲突标记留在树里，stash 条目保留
+ *   { dirty, files }    有改动但非标记冲突 / apply 异常部分应用——现场保留，交人工核对
+ *   { preserved }       无法自动恢复且树未被污染（如未跟踪占位冲突）
+ * 防双重应用：pop --index 失败可能留下"半应用"树（工作区改了、index 没还原），
+ * 盲目 plain pop 会在半应用之上再应用一次。故失败后先 reset --hard 回到 HEAD，
+ * 再 plain apply 一次（干净基线上的单次应用），结果只有"标记冲突"或"完整应用"两种。
+ */
+function tryRestoreStash(workPath, idx) {
+  const ref = '"stash@{' + idx + '}"';
+  const pop = run('git stash pop --index ' + ref, workPath);
+  if (pop.ok) return { done: true };
+  const conflicted = conflictedPaths(workPath);
+  if (conflicted.length === 0) {
+    // 非冲突类失败（如未跟踪文件还原撞车）：树可能已被部分应用——如实分类，绝不谎报"未动"
+    const s = run('git status --porcelain --untracked-files=no', workPath);
+    if (s.ok && s.out) return { dirty: true, files: s.out.split(/\r?\n/).filter(Boolean) };
+    return { preserved: true };
+  }
+  // 有冲突标记：--index 的失败树状态不透明（半应用 + unmerged 索引，checkout -- 会拒绝）。
+  // 先 reset --hard 回到本次合并的 HEAD（用户改动安全躺在 stash 里），再 plain apply 一次，
+  // 让冲突以标准 stash-pop-conflict 形态单次落盘（标记 + 条目保留），杜绝双重应用。
+  const undo = run('git reset --hard --quiet', workPath);
+  if (!undo.ok) return { conflicted: true };
+  const apply = run('git stash apply ' + ref, workPath);
+  if (conflictedPaths(workPath).length > 0) return { conflicted: true };
+  if (!apply.ok) {
+    const s2 = run('git status --porcelain --untracked-files=no', workPath);
+    if (s2.ok && s2.out) return { dirty: true, files: s2.out.split(/\r?\n/).filter(Boolean) };
+    return { preserved: true };
+  }
+  // plain apply 完全成功（首轮失败仅因 --index 还原不了 staged 分区）：补 drop 收尾
+  const drop = run('git stash drop ' + ref, workPath);
+  if (drop.ok) return { done: true };
+  return { dirty: true, files: conflictedPaths(workPath) };
+}
+
+/**
+ * 恢复 autostash。返回 { state, files?, note? }：
+ *   none         未建条目，无需恢复
+ *   restored     已完全恢复
+ *   conflict     恢复冲突（标记在树里、条目保留）——后提交者解决，交用户决策
+ *   dirty        apply 异常 / 部分应用——现场保留交人工核对
+ *   preserved    无法自动恢复且树未被污染——条目保留交人工
+ *   stash-moved  stash 顶层已非本次条目——绝不动别人的 stash，保留现场
+ */
+function autostashPop(workPath, st) {
+  if (!st.ok || !st.created) return { state: 'none' };
+  const cur = run('git rev-parse -q --verify "refs/stash"', workPath);
+  if (!cur.ok || cur.out !== st.oid) {
+    return { state: 'stash-moved', note: 'stash 顶层条目非本次自动暂存（' + st.stashId + '），未自动恢复' };
+  }
+  const list = run('git stash list', workPath);
+  const top = list.ok ? (list.out.split(/\r?\n/)[0] || '') : '';
+  const m = top.match(/^stash@\{(\d+)\}/);
+  if (!m) return { state: 'preserved', note: 'stash 列表解析失败（' + st.stashId + '）' };
+  const r = tryRestoreStash(workPath, m[1]);
+  if (r.done) return { state: 'restored' };
+  if (r.conflicted) return { state: 'conflict', files: conflictedPaths(workPath), note: '条目保留：' + top };
+  if (r.dirty) return { state: 'dirty', files: r.files, note: '条目保留：' + top };
+  return { state: 'preserved', note: '条目保留：' + top };
+}
+
 function main() {
   const args = process.argv.slice(2);
   const wsRoot = args[0];
@@ -209,7 +314,7 @@ function main() {
   // ── 阶段 1：预检 ──────────────────────────────────────────
   const prechecks = [];
   for (const rp of repos) {
-    const rec = { name: rp.name, status: 'ok', main: null, target: null, temp: false, reason: null };
+    const rec = { name: rp.name, status: 'ok', main: null, target: null, temp: false, reason: null, uncommitted: 0 };
     if (!fs.existsSync(path.join(rp.repo, '.git'))) {
       rec.status = 'skipped';
       rec.reason = 'no-repo';
@@ -257,13 +362,8 @@ function main() {
         prechecks.push(rec);
         continue;
       }
-      const status = run('git status --porcelain', rp.work);
-      if (!status.ok || status.out) {
-        rec.status = 'failed';
-        rec.reason = 'dirty-worktree';
-        prechecks.push(rec);
-        continue;
-      }
+      // 检出脏不再拦截：记录未提交项数，执行阶段 autostash 让路、合并后恢复（ADR 0008 扩展）
+      rec.uncommitted = countUncommitted(rp.work);
       const current = run('git branch --show-current', rp.work);
       if (current.out && current.out !== main && !allowCheckout) {
         rec.status = 'failed';
@@ -279,7 +379,7 @@ function main() {
         continue;
       }
     } else {
-      // 指定分支路径：已合并则跳过；当前检出即目标且干净 → 就地；否则临时 worktree
+      // 指定分支路径：已合并则跳过；当前检出即目标 → 就地（autostash）；否则临时 worktree
       if (mergedToTarget(rp.repo, branch, target)) {
         rec.status = 'skipped';
         rec.reason = 'already-merged';
@@ -288,15 +388,10 @@ function main() {
       }
       const current = run('git branch --show-current', rp.work);
       if (current.out === target) {
-        const status = run('git status --porcelain', rp.work);
-        if (!status.ok || status.out) {
-          rec.status = 'failed';
-          rec.reason = 'dirty-worktree';
-          prechecks.push(rec);
-          continue;
-        }
+        // 就地合并：同主干快路径，检出脏不拦截，执行阶段 autostash 让路 / 恢复
+        rec.uncommitted = countUncommitted(rp.work);
       } else {
-        rec.temp = true; // 执行阶段创建临时 worktree
+        rec.temp = true; // 执行阶段创建临时 worktree（基于 origin/<target>，不碰用户检出）
       }
     }
     prechecks.push(rec);
@@ -306,7 +401,11 @@ function main() {
   prechecks.forEach(p => {
     if (p.status === 'failed') console.log('FAIL ' + p.name + ': ' + p.reason);
     else if (p.status === 'skipped') console.log('SKIP ' + p.name + ': ' + p.reason);
-    else console.log('OK   ' + p.name + ' → 合并至 ' + p.target + (p.temp ? '（临时 worktree）' : ''));
+    else {
+      let note = p.temp ? '（临时 worktree）' : '';
+      if (!p.temp && p.uncommitted > 0) note += '（检出有 ' + p.uncommitted + ' 项未提交改动，将自动暂存、合并后恢复）';
+      console.log('OK   ' + p.name + ' → 合并至 ' + p.target + note);
+    }
   });
 
   if (hasPrecheckFailure) {
@@ -336,32 +435,49 @@ function main() {
 
     const target = p.target;
     const mergeMsg = "Merge branch '" + branch + "'";
+    let st = null; // autostash 句柄（仅主干 / 就地路径建）
+    // 统一出口：凡建过暂存，离开本仓库前必恢复；恢复未完全 → autostashPending（退出码 2 交用户决策）
+    const finish = (status, detail) => {
+      let pending = false;
+      if (st) {
+        const pr = autostashPop(rp.work, st);
+        if (pr.state !== 'none' && pr.state !== 'restored') {
+          pending = true;
+          detail += '; autostash-' + pr.state +
+            (pr.files && pr.files.length ? ' [' + pr.files.join(', ') + ']' : '') +
+            (pr.note ? ' ' + pr.note : '');
+        }
+      }
+      results[i].status = status;
+      results[i].detail = detail;
+      results[i].autostashPending = pending;
+      if (status !== 'merged' && status !== 'skipped') stopped = true;
+    };
 
     if (target === p.main) {
-      // ── 主干路径（快路径） ──
+      // ── 主干路径（快路径）：检出未提交改动 autostash 让路，交付后自动恢复 ──
+      st = autostashPush(rp.work, 'merge-' + branch + '-into-' + target);
+      if (!st.ok) {
+        finish('failed', 'autostash-failed: ' + st.err);
+        continue;
+      }
       const current = run('git branch --show-current', rp.work);
       if (current.out !== target) {
         const co = run('git checkout --quiet "' + target + '"', rp.work);
         if (!co.ok) {
-          results[i].status = 'failed';
-          results[i].detail = 'checkout-failed: ' + co.err.split(/\r?\n/)[0];
-          stopped = true;
+          finish('failed', 'checkout-failed: ' + co.err.split(/\r?\n/)[0]);
           continue;
         }
       }
       const pull = run('git pull --ff-only --quiet origin "' + target + '"', rp.repo);
       if (!pull.ok) {
-        results[i].status = 'failed';
-        results[i].detail = 'pull-failed: ' + pull.err.split(/\r?\n/)[0];
-        stopped = true;
+        finish('failed', 'pull-failed: ' + pull.err.split(/\r?\n/)[0]);
         continue;
       }
       const merge = run('git merge --no-ff -m "' + mergeMsg + '" "' + branch + '"', rp.repo);
       if (!merge.ok) {
         run('git merge --abort', rp.repo);
-        results[i].status = 'failed';
-        results[i].detail = 'merge-failed: ' + merge.err.split(/\r?\n/)[0];
-        stopped = true;
+        finish('failed', 'merge-failed: ' + merge.err.split(/\r?\n/)[0]);
         continue;
       }
       let push = run('git push origin "' + target + '"', rp.repo);
@@ -374,22 +490,18 @@ function main() {
         if (!push.ok) {
           const code2 = classifyPushError(push.err);
           if (code2 === 'branch-protected') {
-            results[i].status = 'need-mr';
-            results[i].detail = 'branch-protected（目标分支受保护，请改用 MR 出口）';
+            finish('need-mr', 'branch-protected（目标分支受保护，请改用 MR 出口）');
           } else {
-            results[i].status = 'failed';
-            results[i].detail = 'push-failed: ' + (push.err || '').split(/\r?\n/)[0];
+            finish('failed', 'push-failed: ' + (push.err || '').split(/\r?\n/)[0]);
           }
-          stopped = true;
           continue;
         }
       }
-      results[i].status = 'merged';
-      results[i].detail = 'merged+pushed origin/' + target;
+      finish('merged', 'merged+pushed origin/' + target);
       continue;
     }
 
-    // ── 指定分支路径（当前检出即目标 → 就地；否则临时 worktree） ──
+    // ── 指定分支路径（当前检出即目标 → 就地 + autostash；否则临时 worktree，不碰检出） ──
     let workDir = rp.work;
     let tmpDir = null;
     const current = run('git branch --show-current', rp.work);
@@ -398,18 +510,19 @@ function main() {
       const base = hasRef(rp.repo, 'refs/remotes/origin/' + target) ? 'origin/' + target : target;
       const add = run('git worktree add --detach "' + tmpDir + '" "' + base + '"', rp.repo);
       if (!add.ok) {
-        results[i].status = 'failed';
-        results[i].detail = 'worktree-add-failed: ' + add.err.split(/\r?\n/)[0];
-        stopped = true;
+        finish('failed', 'worktree-add-failed: ' + add.err.split(/\r?\n/)[0]);
         continue;
       }
       workDir = tmpDir;
     } else {
+      st = autostashPush(rp.work, 'merge-' + branch + '-into-' + target);
+      if (!st.ok) {
+        finish('failed', 'autostash-failed: ' + st.err);
+        continue;
+      }
       const pull = run('git pull --ff-only --quiet origin "' + target + '"', rp.repo);
       if (!pull.ok) {
-        results[i].status = 'failed';
-        results[i].detail = 'pull-failed: ' + pull.err.split(/\r?\n/)[0];
-        stopped = true;
+        finish('failed', 'pull-failed: ' + pull.err.split(/\r?\n/)[0]);
         continue;
       }
     }
@@ -418,9 +531,7 @@ function main() {
     if (!merge.ok) {
       run('git merge --abort', workDir);
       cleanupTempWorktree(rp.repo, tmpDir);
-      results[i].status = 'failed';
-      results[i].detail = 'merge-failed: ' + merge.err.split(/\r?\n/)[0];
-      stopped = true;
+      finish('failed', 'merge-failed: ' + merge.err.split(/\r?\n/)[0]);
       continue;
     }
 
@@ -439,26 +550,26 @@ function main() {
         const code2 = classifyPushError(push.err);
         cleanupTempWorktree(rp.repo, tmpDir);
         if (code2 === 'branch-protected') {
-          results[i].status = 'need-mr';
-          results[i].detail = 'branch-protected（目标分支受保护，请改用 MR 出口）';
+          finish('need-mr', 'branch-protected（目标分支受保护，请改用 MR 出口）');
         } else {
-          results[i].status = 'failed';
-          results[i].detail = 'push-failed: ' + (push.err || '').split(/\r?\n/)[0];
+          finish('failed', 'push-failed: ' + (push.err || '').split(/\r?\n/)[0]);
         }
-        stopped = true;
         continue;
       }
     }
     cleanupTempWorktree(rp.repo, tmpDir);
-    results[i].status = 'merged';
-    results[i].detail = 'merged+pushed origin/' + target + (tmpDir ? '（临时 worktree）' : '');
+    finish('merged', 'merged+pushed origin/' + target + (tmpDir ? '（临时 worktree）' : ''));
   }
 
   results.forEach(r => {
     console.log(r.status.toUpperCase() + ' ' + r.name + (r.detail ? ' — ' + r.detail : ''));
+    if (r.autostashPending) {
+      console.log('AUTOSTASH_PENDING ' + r.name + ': 暂存的未提交改动未自动恢复（stash 条目保留）——列冲突点，用户二选一：agent 解决 / 手动解决（协议见 SKILL 解读）');
+    }
   });
 
-  const ok = results.every(r => r.status === 'merged' || r.status === 'skipped');
+  // autostashPending 按失败退出：交付可能已完成，但用户改动还挂在 stash，必须决策处理后重跑确认
+  const ok = results.every(r => (r.status === 'merged' || r.status === 'skipped') && !r.autostashPending);
   console.log('---');
   console.log('MERGE_RESULT', JSON.stringify({ phase: 'execute', target: targetArg || null, results }));
   process.exit(ok ? 0 : 2);
@@ -466,4 +577,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { run, detectMain, mergedTo, mergedToMain, mergedToTarget, classifyPushError, loadApps, buildRepos };
+module.exports = { run, detectMain, mergedTo, mergedToMain, mergedToTarget, classifyPushError, loadApps, buildRepos, autostashPush, autostashPop };

package/cbb/worktrees/skills/cbb-worktree-push/SKILL.md

@@ -337,14 +337,15 @@ node "<skill_dir>/scripts/check-unarchived.js" "<ws_root>" "<branch>"
 node "<skill_dir>/scripts/merge-branches.js" "<ws_root>" "<branch>" --apps "<app1,app2>" --target "<目标>"
 ```
 
-- 缺省 / `--target` 等于探测主干 → 主干快路径（本地主干检出上 `merge --no-ff` → push）
-- `--target` 为非主干分支 → **临时 worktree** 合并（基于 `origin/<目标>`，不动用户检出）
+- 缺省 / `--target` 等于探测主干 → 主干快路径（检出未提交改动 autostash 让路 → 本地主干检出上 `merge --no-ff` → push → 自动恢复暂存）
+- `--target` 为非主干分支：目标 == 当前检出 → 就地合并（同上 autostash）；否则 **临时 worktree** 合并（基于 `origin/<目标>`，不动用户检出，无需暂存）
 
 **解读末行 `MERGE_RESULT`**：
 - 退出码 0 → 交付完成
 - `need-mr`（目标分支受保护）→ 报明细并**转出口 A**
 - `failed`（含 `merge-failed` / `push-failed`）→ 报明细，修复后重跑（幂等）
 - `not-on-main`（仅主干路径）→ 空间根检出被其他需求占用（本地模式进行中）：**先收尾该本地需求或改用出口 A 提 MR**；不得用 `--allow-checkout` 抢占（该参数属本地模式收尾，会切走占用者的工作区）
+- `MERGED` 但含 `AUTOSTASH_PENDING`（退出码 2）→ **交付已完成**，仅暂存恢复遇冲突：列冲突点，用户二选一（**agent 解决**——消除标记后 `git stash drop`，不代提交 / **用户手动**），处理协议与 close 出口二解读一致
 
 报告形态：
 
@@ -496,4 +497,4 @@ node "<skill_dir>/scripts/merge-branches.js" "<ws_root>" "<branch>" --apps "<app
 | `make-mr-urls.js` | 生成预填 MR/PR 创建链接（平台识别 + 远端校验 + diff 判定 + `--open` 开浏览器） | ws_root, branch, target（或 wt_path, target）, --platform, --open | 0/1/2 |
 | `push-core.js` | 推送核心（classifyError / pushSingle / collectRemoteMetadata，共享脚本，源仓库真源在 `_shared/scripts/`） | （共享模块） | - |
 | `check-unarchived.js` | 未归档 change 检查（Step 7 直合并的归档前置，共享脚本） | ws_root, branch | 0/1 |
-| `merge-branches.js` | 直合并（Step 7 出口 B / 收尾门禁；预检 → merge --no-ff → push；`--target` 支持测试分支，共享脚本） | ws_root, branch, --apps / --target / --allow-checkout / --dry-run / --check | 0/1/2 |
+| `merge-branches.js` | 直合并（Step 7 出口 B / 收尾门禁；预检 → merge --no-ff → push，检出未提交改动 autostash 让路 / 恢复；`--target` 支持测试分支，共享脚本） | ws_root, branch, --apps / --target / --allow-checkout / --dry-run / --check | 0/1/2 |