@jspg-ai/coding-bb 0.0.1

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

@@ -0,0 +1,307 @@
+---
+name: openspec-push-worktrees
+description: "跨 worktree 提交并推送当前需求的所有关联仓库。触发：用户说'提交'/'commit'/'push'/'推送'/'提交并push'/'推到远端'；用户在 .worktrees/worktree-<需求名>/ 下工作要求批量推送；apply 完成后准备推送所有 worktree；close-worktree 前需要先推送未提交改动。"
+license: MIT
+compatibility: Requires git (>=2.30) and Node.js (>=16.7.0). All commands are pure Node.js scripts under `scripts/`, fully cross-platform (Windows / macOS / Linux, bash / PowerShell / Git Bash).
+metadata:
+  author: Contributors
+  version: "1.0"
+  generatedBy: coding-bb
+---
+
+# Push Worktrees（跨平台脚本化版本 v1.0）
+
+跨 worktree 提交并推送当前需求的所有关联仓库到 origin。专门解决"开发完成后批量推送"和"用户口语化提交并push"两类场景，弥补 [openspec-init-worktree Step 3.4](file:///d:/workspace/va-ai/coding-bb/cbb/worktrees/skills/openspec-init-worktree/SKILL.md) 仅推送初始空 commit 的缺口。
+
+**启动时声明：** "我正在使用 openspec-push-worktrees 技能来批量提交并推送当前需求的所有 worktree 仓库。"
+
+## 核心原则
+
+- 本技能的所有原子操作封装为 `scripts/*.js` Node.js 脚本，**跨平台执行**
+- **两阶段**：先 `commit-worktrees.js` 提交所有 dirty 仓库，再 `push-worktrees.js` 推送所有 worktree 仓库。两个脚本独立退出码，AI agent 区分阶段
+- 复用 `openspec-push-worktrees/scripts/push-core.js` 的 `pushSingle` / `classifyError` —— 与 `openspec-init-worktree` 的 `push-branches.js` 行为完全一致，错误码契约统一
+- `find-workspace-root.js` / `find-target-worktree.js` 为共享脚本：源仓库真源在 `cbb/worktrees/_shared/scripts/`，部署后位于本 skill 的 `scripts/` 下，与 `openspec-extend-worktree` / `openspec-close-worktree` 逻辑完全一致
+- **本技能支持两层执行位置**（与 `openspec-close-worktree` 对称）：
+  - 工作空间根目录（`WS_ROOT/`）
+  - worktree 内部（`WS_ROOT/.worktrees/worktree-<需求名>/` 或其子目录）
+- 输入约定：**自由文本**（commit 信息、需求名等）直接在对话中提问并等待回复；**固定选项多选**（如 "应用统一信息 vs 分别信息"）使用 `AskUserQuestion`
+
+---
+
+## 调用脚本的统一方式
+
+**所有脚本必须用绝对路径调用**（Qoder 沙箱中 AI agent 的 cwd 不一定是技能目录）。
+
+```
+node "<ws_root>/.qoder/skills/openspec-push-worktrees/scripts/<name>.js" <参数>
+```
+
+脚本输出：
+- 人类可读报告（OK / FAIL / WARN）
+- 机器可读摘要（末行以 `COMMIT_RESULT` / `PUSH_RESULT` 开头）
+- AI agent 解析末行摘要决定下一步
+
+---
+
+## Step 0：定位工作空间
+
+```bash
+node "<ws_root>/.qoder/skills/openspec-push-worktrees/scripts/find-workspace-root.js"
+```
+
+**解读末行**：
+- 退出码 0 + 末行（纯路径） → WS_ROOT
+- 退出码 1 → 未找到工作空间根目录，**终止流程**
+
+---
+
+## Step 1：识别目标 worktree
+
+```bash
+node "<ws_root>/.qoder/skills/openspec-push-worktrees/scripts/find-target-worktree.js" "<ws_root>"
+```
+
+**解读末行**：
+- 退出码 0 + 末行（需求名） → 唯一识别，自动用之
+- 退出码 1 + 末行 `MULTIPLE_WORKTREEES` → 多个 worktree，AI agent 在对话中让用户输入序号或分支名
+- 退出码 2 + 末行 `NO_WORKTREE` → 无 worktree，提示用户先用 `openspec-init-worktree`
+
+---
+
+## Step 2：扫描所有 worktree 仓库状态（dry-run）
+
+```bash
+# 仅 commit 阶段先做 dry-run 预览
+node "<ws_root>/.qoder/skills/openspec-push-worktrees/scripts/commit-worktrees.js" "<ws_root>" "<branch>" --message "preview" --dry-run
+```
+
+**解读末行 `COMMIT_RESULT`**：每项仓库的状态
+- `dry-run`：dirty 文件数 + 预览 commit message
+- `skipped (clean)`：干净仓库，无需处理
+- `skipped (has-ahead-commits)`：已有 ahead commit（只 push，不重复 commit）
+- `skipped (skip-repo)`：用户指定跳过
+- `failed`：错误
+
+> ⓘ **dry-run 必跑**：让用户确认将要 commit 的内容，避免误纳 `.idea/` 等被 git 忽略的文件（虽然 `git add -u` 已天然排除，但 dry-run 仍是最后的兜底确认）。
+
+---
+
+## Step 3：收集 commit 信息（对话中提问）
+
+AI agent 在执行真实 commit 前**必须**在对话中向用户确认 commit 信息。**禁止**自动生成。
+
+**问询模板**（直接对话提问，不用 `AskUserQuestion`）：
+
+```
+检测到以下 worktree 仓库有未提交改动：
+  - workspace: 5 个文件（CONFIG.json, openspec/changes/foo/...）
+  - ep-foo-app: 12 个文件
+  - ep-bar-app: 3 个文件
+
+请提供 commit 信息：
+  [1] 所有仓库用同一条信息（推荐简单场景）
+  [2] 每仓库分别提供（推荐多仓库改不同东西）
+
+回复示例（统一）：
+  feat(<branch>): 实现客户运费逻辑
+
+回复示例（分别）：
+  workspace: chore(<branch>): 同步 openspec 标准
+  ep-foo-app: feat(<branch>): 实现 saveClientExpectFreight
+  ep-bar-app: refactor(<branch>): 拆分 PlanService
+```
+
+**自动建议**（仅作辅助）：agent 可以从 `openspec/changes/<branch>/tasks.md` 已完成的 task 描述生成建议，但**必须**由用户确认或修改后才能传给脚本。
+
+---
+
+## Step 4：批量 commit
+
+```bash
+# 统一信息
+node "<ws_root>/.qoder/skills/openspec-push-worktrees/scripts/commit-worktrees.js" "<ws_root>" "<branch>" --message "feat(<branch>): 实现客户运费逻辑"
+
+# 多仓库分别
+node "..." "<ws_root>" "<branch>" --per-repo "ep-foo-app:feat(<branch>): 实现 saveClientExpectFreight;ep-bar-app:refactor(<branch>): 拆分 PlanService"
+
+# 含未追踪文件
+node "..." "<ws_root>" "<branch>" --message "..." --untracked
+
+# wt_path 形式（用户在 worktree 内）
+node "..." "<ws_root>/.worktrees/worktree-<branch>" --message "..."
+```
+
+**选项**：
+| 选项 | 说明 |
+|------|------|
+| `--message / -m` | 必填（除非 --per-repo 完全覆盖）。commit 信息 |
+| `--per-repo "<name>:msg;<name>:msg"` | 覆盖特定仓库的 commit 信息 |
+| `--untracked` | 同时 stage 未追踪文件（默认 `git add -u`，加此项时 `git add -A`） |
+| `--allow-empty` | 允许空提交 |
+| `--dry-run` | 仅预览，不实际 add/commit |
+| `--skip-repo <name>` | 跳过指定仓库 |
+
+**解读末行 `COMMIT_RESULT`**：
+- 退出码 0 → 全部成功（包含全部 skipped）
+- 退出码 2 → 部分 commit 失败，**阻塞流程**
+
+**错误处理**：
+- 某仓库 `commit-failed`（如 hook 失败、lint 失败）→ AI 报告失败详情，让用户修复后重试；**禁止**自动 `--no-verify` 绕过 hook
+- 某仓库 `add-failed` → 检查文件权限 / 路径
+- 某仓库 `no-message`（用了 --per-repo 但没覆盖该仓库） → 让用户补充
+
+---
+
+## Step 5：批量 push
+
+```bash
+node "<ws_root>/.qoder/skills/openspec-push-worktrees/scripts/push-worktrees.js" "<ws_root>" "<branch>"
+
+# 或 wt_path 形式
+node "..." "<ws_root>/.worktrees/worktree-<branch>"
+```
+
+**解读末行 `PUSH_RESULT`**：
+- 退出码 0 + 末行 `PUSH_RESULT [...]` → 全部推送成功
+- 退出码 2 + 末行 `PUSH_RESULT [...]`（含 `failed` 或 `remote-exists` 项） → **阻塞流程**
+
+**错误处理**（与 init-worktree Step 3.4 一致）：
+
+| 错误码 | 处理 |
+|--------|------|
+| `ssh-auth-failed` / `https-auth-failed` / `network-unreachable` / `branch-protected` / `no-remote` / `non-fast-forward` / `unknown` | 输出失败明细，按 error 码分组汇总。AskUserQuestion 提供三个选项：1) 修复后重试（推荐） 2) 跳过失败仓库继续 3) 完全终止 |
+| `remote-exists` | 先在纯文本中输出远程 commit 元信息 + 本地 HEAD hash（**二次确认**），再 AskUserQuestion 提供两个选项：1) 关联到 origin/&lt;branch&gt;（执行 set-upstream-to） 2) 终止流程 |
+
+**禁止**：脚本**禁止**自动 `git branch --set-upstream-to=origin/<branch>`；AI 在询问关联前**必须**先输出 commit 元信息。
+
+---
+
+## Step 6：汇总报告
+
+```
+=== 批量 commit + push 完成 ===
+目标 worktree: <branch>
+  workspace:
+    commit: ✅ 5 个文件
+    push:   ✅ origin/<branch>
+  ep-foo-app:
+    commit: ⏭️ skipped (clean)
+    push:   ✅ origin/<branch>
+  ep-bar-app:
+    commit: ❌ 失败 (commit-failed: pre-commit hook failed)
+    push:   ⏸️ 未执行
+```
+
+**任一仓库失败** → 阻塞整个流程，AI 必须询问用户决策。
+
+---
+
+## 最终报告
+
+```
+✅ worktree 推送完成
+  需求名：<branch>
+  工作空间根：<ws_root>
+  Commit 摘要：
+    workspace: feat(<branch>): 实现 XX
+    ep-foo-app: skipped (clean)
+    ep-bar-app: skipped (clean)
+  Push 摘要：
+    workspace: ✅ origin/<branch>
+    ep-foo-app: ✅ origin/<branch>
+    ep-bar-app: ⚠️  远程分支已存在（需用户决策 → 已关联）
+  AI 配置目录：worktree 内独立安装，无需处理
+  后续：可继续开发 / 调 /opsx:verify 验证 / 调 /opsx:archive 归档 / 调 /opsx:close 关闭
+```
+
+---
+
+## 快速参考
+
+| 场景 | 处理方式 |
+|------|----------|
+| 用户说"提交并push"且 cwd 在 worktree 内 | 自动用 cwd 反推分支，Step 2 扫描后进入 Step 3 问 commit 信息 |
+| 用户说"提交并push"且 cwd 在 WS_ROOT | Step 0 定位后，多个 worktree 时让用户选 |
+| commit 信息缺失 | 必须询问用户；禁止自动生成（可基于 apply task 上下文给建议） |
+| 多仓库需不同 commit 信息 | 用 `--per-repo "ep-foo:m1;ep-bar:m2"`，必须由用户逐条提供 |
+| 仓库干净 | commit-worktrees 自动 skipped，只 push 不 commit |
+| 仓库已有 ahead commit | commit-worktrees 自动 skipped（不重复 commit），只 push |
+| 未追踪文件 | 默认不纳入（避免误纳 .idea）；用户明确要求时加 `--untracked` |
+| 远程分支已存在 | push 退出码 2，AI 输出元信息后由用户决策（关联/终止） |
+| push 失败（SSH/HTTPS/网络/保护） | push 退出码 2，AI 按错误码分类处理，阻塞并询问用户 |
+| close-worktree 前调用 | 先调本 skill 把 ahead 推送完，避免 close 时丢提交 |
+| --dry-run | 任何时候想预览将要 commit 的内容时使用，不实际修改任何东西 |
+
+---
+
+## 常见错误
+
+### 自动生成 commit 信息不让用户确认
+
+- **问题：** agent 拍脑袋写 "feat: xxx"，与用户实际意图不符
+- **修复：** Step 3 必须**直接对话提问**让用户输入或确认
+
+### 误纳未追踪文件
+
+- **问题：** 用户 `.idea/` / `node_modules/` 等被自动 `git add -A` 误纳
+- **修复：** 默认 `git add -u`（仅 tracked modified/deleted）；用户明确要求时加 `--untracked`；提交前 Step 2 dry-run 预览
+
+### close-worktree 前忘记先 push
+
+- **问题：** 调 close-worktree 时，close-safety-check 检测到 ahead 提交 → 询问用户「先推送 / 接受丢失 / 中止」；用户没意识到要调本 skill
+- **修复：** close-worktree/SKILL.md Step 3.4 决策点已提示「先推送」选项；本 skill 是该选项的执行入口
+
+### apply 完成后不调 push 直接 close
+
+- **问题：** apply 实现完 → 用户关掉 IDE → 调 close-worktree → ahead 提交永久丢失
+- **修复：** 强烈建议 apply 完成后立即调本 skill 推送；或 close-worktree Step 3.4 兜底
+
+### 多仓库用同一条 commit 信息
+
+- **问题：** workspace 改了 CONFIG.json，ep-foo-app 改了 Java 代码，硬塞同一条 "feat: 实现 XX" 信息不准确
+- **修复：** 用 `--per-repo` 模式，让用户逐仓库提供
+
+### push 失败时跳过失败仓库直接继续
+
+- **问题：** push 部分失败但脚本退出码 0，AI 误以为成功
+- **修复：** push-worktrees.js 退出码 2 时必须阻塞流程并询问用户；禁止脚本或 AI 自动跳过失败仓库
+
+### 远程分支已存在时自动 set-upstream
+
+- **问题：** 看到 origin/&lt;branch&gt; 已存在就直接 `git branch --set-upstream-to`，可能关联到他人的同名分支
+- **修复：** 脚本输出 metadata 后必须由用户决策；AI 在 AskUserQuestion 之前必须先输出 commit 元信息
+
+---
+
+## 红线规则
+
+**绝不允许**
+
+- 自动生成 commit 信息不让用户确认
+- 默认 `git add -A` 误纳未追踪文件
+- push 失败后跳过失败仓库直接继续
+- 远程分支已存在时脚本自动 set-upstream-to
+- AI 询问关联选项前不输出 commit 元信息
+- 沙箱内 node 不可用时强行继续 → 改为 fail-fast 提示用户
+
+**必须执行**
+
+- 严格按 Step 0 → 1 → 2 → 3 → 4 → 5 → 6 顺序执行
+- 所有脚本调用以 `node "..." "<绝对路径>"` 形式发起
+- Step 2 dry-run 必跑，让用户看到将要 commit 的内容
+- Step 3 必问用户 commit 信息（自由文本），禁止自动生成
+- commit 信息涉及业务语义时（feature/refactor/fix 等）必须从 apply task 上下文生成建议并由用户确认
+- commit-worktrees / push-worktrees 退出码 2 时必须阻塞流程
+- 远程分支已存在时 AI 必须先输出 commit 元信息再询问
+
+---
+
+## 附录：脚本清单
+
+| 脚本 | 功能 | 参数 | 退出码 |
+|------|------|------|--------|
+| `find-workspace-root.js` | 定位工作空间根目录（共享脚本，源仓库真源在 `_shared/scripts/`） | 无 | 0/1 |
+| `find-target-worktree.js` | 目标需求名识别（共享脚本，源仓库真源在 `_shared/scripts/`） | ws_root | 0/1/2 |
+| `commit-worktrees.js` | 批量 commit（默认 `-u`，加 `--untracked` 时 `-A`） | ws_root, branch, --message / --per-repo / --untracked / --allow-empty / --dry-run / --skip-repo | 0/1/2 |
+| `push-worktrees.js` | 批量 push（复用 push-core 错误归类） | ws_root, branch（或 wt_path） | 0/1/2 |
+| `push-core.js` | 推送核心（classifyError / pushSingle / collectRemoteMetadata，共享脚本，源仓库真源在 `_shared/scripts/`） | （共享模块） | - |

package/cbb/worktrees/skills/openspec-push-worktrees/scripts/commit-worktrees.js

@@ -0,0 +1,269 @@
+require('./silence-popup');
+/**
+ * openspec-push-worktrees 批量 commit 所有 worktree 仓库
+ *
+ * 用法：
+ *   node commit-worktrees.js <ws_root> <branch> --message "msg" [--untracked] [--per-repo "ep-foo:m1;ep-bar:m2"] [--allow-empty] [--dry-run] [--skip-repo name]
+ *   node commit-worktrees.js <wt_path> --message "msg" [options]
+ *
+ * 行为：
+ *   1. 扫描 <ws_root>/.worktrees/worktree-<branch>/ 下所有 git 仓库
+ *   2. 对每个仓库：
+ *      a. git status --porcelain 检测 dirty
+ *      b. 若 clean 或已有 ahead commit → 跳过
+ *      c. git add -u（默认）或 -A（含 untracked，加 --untracked 时）
+ *      d. git commit -m "<message>"
+ *   3. 逐个报告状态，输出末行 COMMIT_RESULT
+ *
+ * 退出码：
+ *   0 - 全部成功（包含全部 skipped）
+ *   1 - 参数错误
+ *   2 - 部分 commit 失败（AI agent 必须阻塞流程）
+ *
+ * --dry-run 时不执行 add/commit，只输出将要 commit 的文件清单
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function parseArgs(argv) {
+  // argv[0] = node, argv[1] = script
+  // 第一个位置参数（argv[2]）如果是 --option 则报错
+  const args = argv.slice(2);
+  if (args.length === 0) {
+    return { error: '用法：node commit-worktrees.js <ws_root|wt_path> <branch?> [options]' };
+  }
+  // 第一个非选项参数
+  const first = args[0];
+  if (first.startsWith('--')) {
+    return { error: '第一个位置参数必须是 <ws_root> 或 <wt_path>' };
+  }
+  const opts = {
+    message: null,
+    perRepo: {},       // { 'ep-foo': 'msg1', 'ep-bar': 'msg2' }
+    untracked: false,
+    allowEmpty: false,
+    dryRun: false,
+    skipRepos: new Set(),
+  };
+  let positional = [first];
+  for (let i = 1; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--message' || a === '-m') {
+      opts.message = args[++i];
+    } else if (a === '--per-repo') {
+      const raw = args[++i] || '';
+      // 解析 "ep-foo:msg1;ep-bar:msg2"
+      for (const part of raw.split(';')) {
+        const idx = part.indexOf(':');
+        if (idx > 0) {
+          opts.perRepo[part.substring(0, idx).trim()] = part.substring(idx + 1);
+        }
+      }
+    } else if (a === '--untracked') {
+      opts.untracked = true;
+    } else if (a === '--allow-empty') {
+      opts.allowEmpty = true;
+    } else if (a === '--dry-run') {
+      opts.dryRun = true;
+    } else if (a === '--skip-repo') {
+      const name = args[++i];
+      if (name) opts.skipRepos.add(name);
+    } else if (a.startsWith('--')) {
+      return { error: '未知选项：' + a };
+    } else {
+      positional.push(a);
+    }
+  }
+  // 解析定位参数
+  if (positional.length === 1) {
+    // wt_path 形式
+    const wtPath = path.resolve(positional[0]);
+    const m = wtPath.match(/^(.+)[\\\/]\.worktrees[\\\/]worktree-(.+)$/);
+    if (!m) {
+      return { error: 'argv[2] 必须是 <ws_root>/.worktrees/worktree-<branch> 形态，或同时传 ws_root + branch' };
+    }
+    return { wsRoot: m[1], branch: m[2], opts };
+  } else if (positional.length >= 2) {
+    return { wsRoot: path.resolve(positional[0]), branch: positional[1], opts };
+  }
+  return { error: '缺少 ws_root / wt_path 参数' };
+}
+
+function isGitRepo(p) {
+  return fs.existsSync(path.join(p, '.git'));
+}
+
+function scanWorktreeRepos(wsRoot, branch) {
+  const wtRoot = path.join(wsRoot, '.worktrees', 'worktree-' + branch);
+  const repos = [];
+  if (!fs.existsSync(wtRoot)) {
+    return { wtRoot, repos, error: 'worktree 目录不存在：' + wtRoot };
+  }
+  if (isGitRepo(wtRoot)) {
+    repos.push({ name: 'workspace', wt: wtRoot, repo: wsRoot });
+  }
+  const entries = fs.readdirSync(wtRoot, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name.startsWith('.')) continue;
+    const appWt = path.join(wtRoot, e.name);
+    if (!isGitRepo(appWt)) continue;
+    repos.push({ name: e.name, wt: appWt, repo: path.join(wsRoot, '.code', e.name) });
+  }
+  return { wtRoot, repos, error: null };
+}
+
+function run(cmd, cwd) {
+  try {
+    return { ok: true, out: execSync(cmd, { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] }).toString().trim() };
+  } catch (e) {
+    return { ok: false, err: (e.stderr ? e.stderr.toString() : e.message || String(e)).trim() };
+  }
+}
+
+function escapeMessageForShell(msg) {
+  // 简单包裹：替换反斜杠和双引号后用双引号包围
+  return '"' + String(msg).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, ' ') + '"';
+}
+
+/**
+ * commit 单个仓库
+ * @returns {{ name, status, files?, ahead?, error?, message? }}
+ */
+function commitSingle(wt, name, message, opts) {
+  // 1. 检查是否 skip
+  if (opts.skipRepos.has(name)) {
+    return { name, status: 'skipped', reason: 'skip-repo' };
+  }
+
+  // 2. 检测 status
+  const status = run('git status --porcelain', wt);
+  if (!status.ok) {
+    return { name, status: 'failed', error: 'status-failed', message: status.err };
+  }
+  const dirtyFiles = status.out ? status.out.split(/\r?\n/).filter(Boolean) : [];
+  if (dirtyFiles.length === 0) {
+    return { name, status: 'skipped', reason: 'clean' };
+  }
+
+  // 3. 检测 ahead（已有 ahead commit 但 dirty？少见，但防止误覆盖）
+  const ahead = run('git log @{u}..HEAD --oneline 2>/dev/null', wt);
+  if (ahead.ok && ahead.out) {
+    return { name, status: 'skipped', reason: 'has-ahead-commits', ahead_count: ahead.out.split('\n').length };
+  }
+
+  // 4. 决定 message（per-repo 优先）
+  const finalMessage = opts.perRepo[name] || message;
+  if (!finalMessage) {
+    return { name, status: 'failed', error: 'no-message', message: '该仓库未指定 commit message（缺少 --per-repo ' + name + ':...）' };
+  }
+
+  if (opts.dryRun) {
+    return { name, status: 'dry-run', files: dirtyFiles, message: finalMessage };
+  }
+
+  // 5. add
+  const addCmd = opts.untracked ? 'git add -A' : 'git add -u';
+  const add = run(addCmd, wt);
+  if (!add.ok) {
+    return { name, status: 'failed', step: 'add', error: 'add-failed', message: add.err };
+  }
+
+  // 6. commit
+  const commitArgs = ['git commit'];
+  if (opts.allowEmpty) commitArgs.push('--allow-empty');
+  commitArgs.push('-m', escapeMessageForShell(finalMessage));
+  const commit = run(commitArgs.join(' '), wt);
+  if (!commit.ok) {
+    return { name, status: 'failed', step: 'commit', error: 'commit-failed', message: commit.err };
+  }
+
+  return { name, status: 'committed', files: dirtyFiles, message: finalMessage };
+}
+
+/**
+ * 编排
+ * @param {{ wsRoot, branch, opts }} params
+ */
+function executeCommit(params) {
+  const { wtRoot, repos, error } = scanWorktreeRepos(params.wsRoot, params.branch);
+  if (error) {
+    return { wtRoot, results: [], error };
+  }
+  const results = [];
+  for (const r of repos) {
+    const res = commitSingle(r.wt, r.name, params.message, params.opts);
+    results.push(res);
+  }
+  return { wtRoot, results, error: null };
+}
+
+module.exports = { parseArgs, scanWorktreeRepos, commitSingle, executeCommit };
+
+function main() {
+  const parsed = parseArgs(process.argv);
+  if (parsed.error) {
+    console.error('❌ ' + parsed.error);
+    process.exit(1);
+  }
+
+  if (!parsed.opts.dryRun && !parsed.opts.message && Object.keys(parsed.opts.perRepo).length === 0) {
+    console.error('❌ 必须传 --message 或 --per-repo（除非 --dry-run）');
+    process.exit(1);
+  }
+
+  console.log('=== 批量 commit 所有 worktree 仓库 ===');
+  console.log('工作空间根：' + parsed.wsRoot);
+  console.log('需求名（分支）：' + parsed.branch);
+  console.log('默认 message：' + (parsed.opts.message || '(无)'));
+  if (Object.keys(parsed.opts.perRepo).length > 0) {
+    console.log('per-repo 覆盖：' + JSON.stringify(parsed.opts.perRepo));
+  }
+  console.log('未追踪文件：' + (parsed.opts.untracked ? '包含 (-A)' : '不包含 (-u)'));
+  console.log('dry-run：' + (parsed.opts.dryRun ? '是' : '否'));
+
+  const { wtRoot, results, error } = executeCommit({
+    wsRoot: parsed.wsRoot,
+    branch: parsed.branch,
+    message: parsed.opts.message,
+    opts: parsed.opts,
+  });
+
+  if (error) {
+    console.error('❌ ' + error);
+    process.exit(1);
+  }
+
+  if (results.length === 0) {
+    console.log('⚠️  未在 worktree 下发现任何 git 仓库');
+    console.log('---');
+    console.log('COMMIT_RESULT', JSON.stringify([]));
+    process.exit(0);
+  }
+
+  // 人类可读报告
+  for (const r of results) {
+    if (r.status === 'committed') {
+      const fileCount = (r.files || []).length;
+      console.log('✅ ' + r.name + ': committed ' + fileCount + ' 个文件');
+    } else if (r.status === 'skipped') {
+      console.log('⏭️  ' + r.name + ': skipped (' + r.reason + (r.ahead_count ? ', ' + r.ahead_count + ' ahead' : '') + ')');
+    } else if (r.status === 'dry-run') {
+      const fileCount = (r.files || []).length;
+      console.log('🔍 ' + r.name + ': dry-run, ' + fileCount + ' 个文件待 commit');
+    } else {
+      console.error('❌ ' + r.name + ': ' + r.status + (r.step ? '[' + r.step + ']' : '') + ' - ' + (r.message || r.error));
+    }
+  }
+
+  const hasFailure = results.some(r => r.status === 'failed');
+
+  console.log('---');
+  console.log('COMMIT_RESULT', JSON.stringify(results));
+  process.exit(hasFailure ? 2 : 0);
+}
+
+if (require.main === module) {
+  main();
+}

package/cbb/worktrees/skills/openspec-push-worktrees/scripts/find-target-worktree.js

@@ -0,0 +1,96 @@
+require('./silence-popup');
+/**
+ * openspec-shared 目标需求名识别
+ *
+ * 唯一真源：cbb/worktrees/_shared/scripts/find-target-worktree.js
+ * 由 scripts/sync-shared.js 展开到各 skill 的 scripts/ 下（extend / close / push）。
+ *
+ * 用法：node find-target-worktree.js <ws_root>
+ *
+ * 优先级：
+ *   1. cwd 在 .worktrees/worktree-xxx/ 内 → 自动从路径反推
+ *   2. .worktrees/ 下只有一个 worktree → 自动选用
+ *   3. 多个 worktree → 按 mtime 倒序，第一个为推荐
+ *
+ * 输出：
+ *   末行输出需求名（用于 AI agent 解析）
+ *   多个时按 [1] xxx ⭐ / [2] yyy 列出
+ *
+ * 退出码：
+ *   0 - 唯一识别（自动或唯一）
+ *   1 - 多个 worktree，需用户输入
+ *   2 - 无 worktree
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const wsRoot = process.argv[2];
+
+if (!wsRoot) {
+  console.error('❌ 用法：node find-target-worktree.js <ws_root>');
+  process.exit(1);
+}
+
+// 优先级 1：cwd 反推
+const cwd = process.cwd();
+const cwdMatch = cwd.match(/\.worktrees[\\\/]worktree-([^\\\/]+)/);
+if (cwdMatch) {
+  const branch = cwdMatch[1];
+  console.log('✅ 从 cwd 反推需求名：' + branch);
+  console.log('---');
+  console.log(branch);
+  process.exit(0);
+}
+
+const worktreesDir = path.join(wsRoot, '.worktrees');
+if (!fs.existsSync(worktreesDir)) {
+  console.error('❌ .worktrees 目录不存在：' + worktreesDir);
+  console.error('   请先执行 openspec-init-worktree 创建 worktree');
+  console.log('---');
+  console.log('NO_WORKTREE');
+  process.exit(2);
+}
+
+// 列出所有 worktree-xxx 目录
+const entries = fs.readdirSync(worktreesDir, { withFileTypes: true })
+  .filter(e => e.isDirectory() && e.name.startsWith('worktree-'))
+  .map(e => ({
+    name: e.name.substring('worktree-'.length),
+    fullName: e.name,
+    path: path.join(worktreesDir, e.name),
+    mtime: fs.statSync(path.join(worktreesDir, e.name)).mtime.getTime(),
+  }));
+
+if (entries.length === 0) {
+  console.error('❌ 未找到任何 worktree');
+  console.error('   请先执行 openspec-init-worktree 创建 worktree');
+  console.log('---');
+  console.log('NO_WORKTREE');
+  process.exit(2);
+}
+
+// 优先级 2：唯一
+if (entries.length === 1) {
+  console.log('✅ 自动选用唯一 worktree：' + entries[0].name);
+  console.log('---');
+  console.log(entries[0].name);
+  process.exit(0);
+}
+
+// 优先级 3：多个 → 按 mtime 倒序
+entries.sort((a, b) => b.mtime - a.mtime);
+
+console.log('⚠️  检测到 ' + entries.length + ' 个 worktree（按最近修改排序）：');
+entries.forEach((e, i) => {
+  if (i === 0) {
+    console.log('  [' + (i + 1) + '] ' + e.name + '  ⭐ (推荐：最近修改)');
+  } else {
+    console.log('  [' + (i + 1) + '] ' + e.name);
+  }
+});
+console.log('请在对话中输入序号(1/2/3)或完整分支名：');
+console.log('---');
+console.log('MULTIPLE_WORKTREEES');
+process.exit(1);