openmatrix 0.2.26 → 0.2.28

package/dist/utils/worktree-sync.js

@@ -0,0 +1,352 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorktreeSyncManager = void 0;
+// src/utils/worktree-sync.ts
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const error_handler_js_1 = require("./error-handler.js");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * WorktreeSyncManager - 管理 Git Worktree 同步
+ *
+ * 当 Agent 在 worktree 中工作时，改动会提交到 worktree 的分支。
+ * 此类负责将这些改动同步回主工作树。
+ *
+ * 同步策略：
+ * 1. 检测 Agent 创建的 worktree
+ * 2. 获取 worktree 中的提交和改动文件
+ * 3. 将改动文件复制到主工作树（或 cherry-pick 提交）
+ * 4. 清理临时 worktree
+ */
+class WorktreeSyncManager {
+    repoPath;
+    gitRoot = null;
+    constructor(repoPath = process.cwd()) {
+        this.repoPath = repoPath;
+    }
+    /**
+     * 获取 git 仓库根目录
+     */
+    async getGitRoot() {
+        if (this.gitRoot)
+            return this.gitRoot;
+        try {
+            const { stdout } = await execAsync('git rev-parse --show-toplevel', { cwd: this.repoPath });
+            this.gitRoot = stdout.trim();
+        }
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'getGitRoot', file: this.repoPath });
+            this.gitRoot = this.repoPath;
+        }
+        return this.gitRoot;
+    }
+    /**
+     * 列出所有 worktree
+     */
+    async listWorktrees() {
+        try {
+            const { stdout } = await execAsync('git worktree list --porcelain', { cwd: this.repoPath });
+            const worktrees = [];
+            const lines = stdout.split('\n');
+            let current = {};
+            for (const line of lines) {
+                if (line.startsWith('worktree ')) {
+                    if (current.path) {
+                        worktrees.push({
+                            path: current.path,
+                            branch: current.branch || '',
+                            commit: current.commit || '',
+                            isMain: current.isMain || false
+                        });
+                    }
+                    current = { path: line.slice(9) };
+                    // 第一个 worktree 是主工作树
+                    current.isMain = worktrees.length === 0;
+                }
+                else if (line.startsWith('HEAD ')) {
+                    current.commit = line.slice(5);
+                }
+                else if (line.startsWith('branch ')) {
+                    current.branch = line.slice(7);
+                }
+            }
+            // 添加最后一个
+            if (current.path) {
+                worktrees.push({
+                    path: current.path,
+                    branch: current.branch || '',
+                    commit: current.commit || '',
+                    isMain: current.isMain || false
+                });
+            }
+            return worktrees;
+        }
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'listWorktrees', file: this.repoPath });
+            return [];
+        }
+    }
+    /**
+     * 获取 Agent worktree 目录
+     *
+     * Claude Code 创建的 worktree 通常在 .claude/worktrees/ 目录下
+     */
+    async getAgentWorktrees() {
+        const worktrees = await this.listWorktrees();
+        const gitRoot = await this.getGitRoot();
+        // 过滤出 Agent 创建的 worktree（通常以 agent- 开头或在 .claude/worktrees 下）
+        return worktrees.filter(w => !w.isMain &&
+            (w.path.includes('.claude/worktrees') || w.path.includes('agent-')));
+    }
+    /**
+     * 获取 worktree 相对于主工作树的改动
+     */
+    async getWorktreeChanges(worktreePath) {
+        try {
+            const gitRoot = await this.getGitRoot();
+            // 获取 worktree 相对于主分支的改动文件
+            const { stdout } = await execAsync(`git diff --name-only HEAD "${worktreePath}"`, { cwd: gitRoot });
+            return stdout.split('\n').filter(f => f.trim());
+        }
+        catch (error) {
+            // 如果上面的方法失败，尝试直接在 worktree 中获取未提交的改动
+            try {
+                const { stdout } = await execAsync('git diff --name-only HEAD', { cwd: worktreePath });
+                return stdout.split('\n').filter(f => f.trim());
+            }
+            catch (innerError) {
+                (0, error_handler_js_1.logError)(innerError, { operation: 'getWorktreeChanges', file: worktreePath });
+                return [];
+            }
+        }
+    }
+    /**
+     * 获取 worktree 中最新提交的改动文件
+     */
+    async getLatestCommitChanges(worktreePath) {
+        try {
+            // 在 worktree 中获取最新提交改动的文件
+            const { stdout } = await execAsync('git diff --name-only HEAD~1 HEAD', { cwd: worktreePath });
+            return stdout.split('\n').filter(f => f.trim());
+        }
+        catch (error) {
+            // 可能只有一个提交，尝试获取与初始提交的差异
+            try {
+                const { stdout } = await execAsync('git diff --name-only HEAD', { cwd: worktreePath });
+                return stdout.split('\n').filter(f => f.trim());
+            }
+            catch (innerError) {
+                (0, error_handler_js_1.logError)(innerError, { operation: 'getLatestCommitChanges', file: worktreePath });
+                return [];
+            }
+        }
+    }
+    /**
+     * 同步 worktree 改动到主工作树
+     *
+     * 策略：
+     * 1. 获取 worktree 中已提交但未同步的改动
+     * 2. 将改动文件复制到主工作树
+     * 3. 在主工作树中暂存这些文件
+     *
+     * @param worktreePath worktree 路径（可选，不提供则自动检测所有 Agent worktree）
+     */
+    async syncWorktreeToMain(worktreePath) {
+        const gitRoot = await this.getGitRoot();
+        const worktrees = worktreePath
+            ? [{ path: worktreePath, branch: '', commit: '', isMain: false }]
+            : await this.getAgentWorktrees();
+        if (worktrees.length === 0) {
+            return [{
+                    success: true,
+                    syncedFiles: [],
+                    error: 'No agent worktrees found'
+                }];
+        }
+        const results = [];
+        for (const wt of worktrees) {
+            try {
+                // 1. 获取改动文件
+                const changedFiles = await this.getLatestCommitChanges(wt.path);
+                if (changedFiles.length === 0) {
+                    results.push({
+                        success: true,
+                        syncedFiles: [],
+                        branch: wt.branch,
+                        error: 'No changes in worktree'
+                    });
+                    continue;
+                }
+                // 2. 复制文件到主工作树
+                const syncedFiles = [];
+                for (const file of changedFiles) {
+                    const srcPath = path.join(wt.path, file);
+                    const destPath = path.join(gitRoot, file);
+                    try {
+                        // 确保目标目录存在
+                        const destDir = path.dirname(destPath);
+                        await fs.mkdir(destDir, { recursive: true });
+                        // 复制文件
+                        await fs.copyFile(srcPath, destPath);
+                        syncedFiles.push(file);
+                    }
+                    catch (copyError) {
+                        (0, error_handler_js_1.logError)(copyError, { operation: 'copyFile', file: srcPath, metadata: { dest: destPath } });
+                    }
+                }
+                // 3. 在主工作树中暂存文件
+                if (syncedFiles.length > 0) {
+                    const filesArg = syncedFiles.map(f => `"${f}"`).join(' ');
+                    await execAsync(`git add ${filesArg}`, { cwd: gitRoot });
+                }
+                // 4. 获取 worktree 的最新提交 hash
+                let commitHash;
+                try {
+                    const { stdout } = await execAsync('git rev-parse HEAD', { cwd: wt.path });
+                    commitHash = stdout.trim();
+                }
+                catch { }
+                results.push({
+                    success: true,
+                    syncedFiles,
+                    commitHash,
+                    branch: wt.branch
+                });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    syncedFiles: [],
+                    branch: wt.branch,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Cherry-pick worktree 的提交到主工作树
+     *
+     * 替代方案：直接 cherry-pick worktree 的提交
+     * 适用于：改动较大、需要保留完整提交历史的场景
+     */
+    async cherryPickWorktreeCommit(worktreePath) {
+        const gitRoot = await this.getGitRoot();
+        try {
+            // 1. 获取 worktree 的最新提交 hash
+            const { stdout: commitHash } = await execAsync('git rev-parse HEAD', { cwd: worktreePath });
+            const hash = commitHash.trim();
+            // 2. 在主工作树中 cherry-pick 这个提交
+            await execAsync(`git cherry-pick ${hash} --no-commit`, { cwd: gitRoot });
+            // 3. 获取被 cherry-pick 的文件列表
+            const { stdout: files } = await execAsync('git diff --name-only --cached', { cwd: gitRoot });
+            const syncedFiles = files.split('\n').filter(f => f.trim());
+            return {
+                success: true,
+                syncedFiles,
+                commitHash: hash
+            };
+        }
+        catch (error) {
+            // Cherry-pick 可能失败（冲突），尝试放弃并返回错误
+            try {
+                await execAsync('git cherry-pick --abort', { cwd: gitRoot });
+            }
+            catch { }
+            return {
+                success: false,
+                syncedFiles: [],
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * 清理已同步的 worktree
+     */
+    async cleanupWorktree(worktreePath) {
+        try {
+            const gitRoot = await this.getGitRoot();
+            // 1. 移除 worktree
+            await execAsync(`git worktree remove "${worktreePath}" --force`, { cwd: gitRoot });
+            // 2. 清理可能的残留分支（如果是临时分支）
+            // 注意：不自动删除分支，因为可能还需要
+            return true;
+        }
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'cleanupWorktree', file: worktreePath });
+            return false;
+        }
+    }
+    /**
+     * 完整的同步流程
+     *
+     * 1. 检测所有 Agent worktree
+     * 2. 同步改动到主工作树
+     * 3. 清理 worktree
+     *
+     * @returns 同步结果
+     */
+    async fullSync() {
+        // 1. 同步
+        const syncResults = await this.syncWorktreeToMain();
+        // 2. 清理已成功同步的 worktree
+        const cleanupResults = [];
+        const worktrees = await this.getAgentWorktrees();
+        for (const wt of worktrees) {
+            const syncResult = syncResults.find(r => r.branch === wt.branch);
+            if (syncResult?.success && syncResult.syncedFiles.length > 0) {
+                const cleanupSuccess = await this.cleanupWorktree(wt.path);
+                cleanupResults.push({ path: wt.path, success: cleanupSuccess });
+            }
+        }
+        return { syncResults, cleanupResults };
+    }
+    /**
+     * 检查是否有未同步的 worktree 改动
+     */
+    async hasUnsyncedChanges() {
+        const worktrees = await this.getAgentWorktrees();
+        for (const wt of worktrees) {
+            const changes = await this.getLatestCommitChanges(wt.path);
+            if (changes.length > 0)
+                return true;
+        }
+        return false;
+    }
+}
+exports.WorktreeSyncManager = WorktreeSyncManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/approve.md

@@ -35,7 +35,7 @@ description: "Use when handling pending approvals including plan review, merge c
 </INTENT-JUDGMENT>
 
 <NO-OTHER-SKILLS>
-执行此技能时，不得调用 superpowers、gsd 或其他任务编排相关的技能。OpenMatrix 独立运行，不依赖外部任务编排系统。
+本 skill 与其他任务编排技能功能重叠，请勿同时使用。
 </NO-OTHER-SKILLS>
 
 <objective>

package/skills/auto.md

@@ -37,14 +37,9 @@ description: "Use when the user wants fully automated task execution with zero m
 </INTENT-JUDGMENT>
 
 <NO-OTHER-SKILLS>
-**绝对禁止**调用以下任何技能或工具：
-- gsd-executor、gsd:* 等 GSD 相关技能
-- superpowers:* 等 superpowers 相关技能
-- 任何其他任务编排相关的 Agent 或工具
+本 skill 与其他任务编排技能功能重叠，请勿同时使用。
 
-**Step 5 只能使用 Agent 工具** — 直接调用 Agent，不通过任何中间层。
-
-违规调用将导致执行失败。
+**Step 5 使用 Agent 工具执行子任务。**
 
 **相关技能**: `/om:brainstorm` (需求探索) | `/om:plan` (方案生成) | `/om:start` (交互式执行) | `/om:status` (状态查看) | `/om:report` (报告)
 </NO-OTHER-SKILLS>
@@ -80,6 +75,22 @@ Step 5:  逐个执行 subagentTasks（调用 Agent 工具）            ← 只
 **执行时不要请求用户确认任何操作。**
 </BYPASS-MODE>
 
+<RED-FLAGS>
+## 红旗警告 - 停止并检查
+
+这些想法意味着你在找借口：
+
+| 想法 | 真相 |
+|-----|------|
+| "全自动不需要检查" | 全自动更需要状态持久化 |
+| "跳过 CLI 调用更快" | CLI 是唯一正确的入口 |
+| "我不需要验证状态" | 上下文压缩会丢失状态 |
+| "直接用 Bash 写代码" | 业务代码必须通过 Agent |
+| "忘记任务顺序没关系" | 用 `openmatrix step` 重新获取 |
+| "这个歧义不重要" | 所有歧义都写入 Meeting |
+
+</RED-FLAGS>
+
 <objective>
 全自动执行任务。读取已有的 plan.md + tasks-input.json，通过 CLI 拆分任务，然后通过 Agent 逐个执行。无交互、无审批、无中断。
 
@@ -101,11 +112,21 @@ openmatrix start --init-only
 
 ### Step 2: 验证前置条件
 
-**检查 plan.md 和 tasks-input.json 是否已存在：**
+**先获取当前 runId：**
+```bash
+cat .openmatrix/current.json 2>/dev/null || echo '{"runId":"run-default"}'
+```
+
+**检查 plan.md 和 tasks-input.json 是否已存在（使用 runId）：**
+
+```bash
+cat .openmatrix/${runId}/tasks-input.json 2>/dev/null || echo "NOT_FOUND"
+cat .openmatrix/${runId}/plan.md 2>/dev/null || echo "NOT_FOUND"
+```
 
+**或通过 CLI 检查（推荐）：**
 ```bash
-cat .openmatrix/tasks-input.json 2>/dev/null || echo "NOT_FOUND"
-cat .openmatrix/plan.md 2>/dev/null || echo "NOT_FOUND"
+openmatrix status --json | jq '.files'
 ```
 
 | 情况 | 处理方式 |
@@ -119,15 +140,17 @@ cat .openmatrix/plan.md 2>/dev/null || echo "NOT_FOUND"
 
 ### Step 3: 调用 CLI 创建任务 ⚠️ 不可跳过
 
+**CLI 自动从当前 runId 目录读取 tasks-input.json 和 plan.md。**
+
 **这是最关键的步骤。必须执行以下命令，不能跳过：**
 
 ```bash
-openmatrix start --tasks-json @.openmatrix/tasks-input.json --quality <质量等级> --mode auto --json
+openmatrix start --tasks-json @tasks-input.json --quality <质量等级> --mode auto --json
 ```
 
 如果启用了 E2E 测试，加上 `--e2e-tests`：
 ```bash
-openmatrix start --tasks-json @.openmatrix/tasks-input.json --quality strict --mode auto --e2e-tests --json
+openmatrix start --tasks-json @tasks-input.json --quality strict --mode auto --e2e-tests --json
 ```
 
 此命令会:
@@ -262,6 +285,11 @@ Agent({
 openmatrix complete TASK-XXX --success
 ```
 
+**注意**: `openmatrix complete` 会自动执行以下操作：
+1. 🔄 **同步 Worktree 改动** - 如果 Agent 在 worktree 中工作，自动将改动同步到主工作树
+2. 📝 **更新上下文** - 将执行摘要写入全局 context.md
+3. ✅ **标记完成** - 更新任务状态并触发 Git 提交
+
 3. **获取下一个任务（必须执行，防止上下文压缩丢失）:**
 ```bash
 openmatrix step --json
@@ -346,8 +374,10 @@ auto 和 start 在同一位置，区别在于：
 - **auto**: 零交互，不询问任何问题，无审批节点，质量通过 --quality 指定
 
 前置条件（同 start）：
-- `.openmatrix/plan.md` — 技术方案（由 /om:plan 生成）
-- `.openmatrix/tasks-input.json` — 结构化元数据（由 /om:plan 生成）
+- `.openmatrix/{runId}/plan.md` — 技术方案（由 /om:plan 生成）
+- `.openmatrix/{runId}/tasks-input.json` — 结构化元数据（由 /om:plan 生成）
+
+CLI 自动通过 `current.json` 定位当前 runId。
 
 如果前置条件不满足，自动调用 /om:plan 生成。
 

package/skills/brainstorm.md

@@ -36,11 +36,7 @@ description: "Use when the user wants to explore requirements, design alternativ
 </INTENT-JUDGMENT>
 
 <NO-OTHER-SKILLS>
-**绝对禁止**调用以下技能（OpenMatrix 完全替代它们）:
-- ❌ superpowers:brainstorming → 你已经在 om:brainstorm 中了
-- ❌ superpowers:* → 全部被 OpenMatrix 替代
-- ❌ gsd:* → 全部被 OpenMatrix 替代
-- ❌ 任何其他任务编排相关的技能
+本 skill 与其他任务编排技能功能重叠，请勿同时使用。
 
 **相关技能**: `/om:research` (领域调研) | `/om:plan` (方案生成) | `/om:start` (任务执行) | `/om:auto` (全自动)
 </NO-OTHER-SKILLS>

package/skills/check.md

@@ -4,7 +4,7 @@ description: 自动检测项目可改进点并提供升级建议，用户确认
 ---
 
 <NO-OTHER-SKILLS>
-执行此技能时，不得调用 superpowers、gsd 或其他任务编排相关的技能。OpenMatrix 独立运行，不依赖外部任务编排系统。
+本 skill 与其他任务编排技能功能重叠，请勿同时使用。
 </NO-OTHER-SKILLS>
 
 <objective>