到 s11, 智能体已经能自主认领和完成任务。但所有任务共享一个目录。两个智能体同时重构不同模块 -- A 改 config.py, B 也改 config.py, 未提交的改动互相污染, 谁也没法干净回滚。

任务板管 "做什么" 但不管 "在哪做"。解法: 给每个任务一个独立的 git worktree 目录, 用任务 ID 把两边关联起来。"各干各的目录, 互不干扰"，任务管目标,，worktree 管目录，按 ID 绑定。

Java实现代码

public class WorktreeTaskIsolationSystem {
    
    // --- 新增配置 ---
    private static final Path REPO_ROOT = detectRepoRoot(WORKDIR);  // Git仓库根目录
    private static final Path TASKS_DIR = REPO_ROOT.resolve(".tasks");
    private static final Path WORKTREES_DIR = REPO_ROOT.resolve(".worktrees");
    private static final Path EVENTS_LOG_PATH = WORKTREES_DIR.resolve("events.jsonl");
    
    // --- 新增：Git 仓库检测 ---
    private static Path detectRepoRoot(Path cwd) {
        try {
            ProcessBuilder pb = new ProcessBuilder("git", "rev-parse", "--show-toplevel");
            pb.directory(cwd.toFile());
            Process process = pb.start();
            
            boolean finished = process.waitFor(10, TimeUnit.SECONDS);
            if (!finished) {
                return cwd;
            }
            
            String output = new String(process.getInputStream().readAllBytes()).trim();
            Path root = Paths.get(output);
            return Files.exists(root) ? root : cwd;
            // 自动检测：自动发现Git仓库根目录
            // 向后兼容：如果不是Git仓库，使用当前目录
        } catch (Exception e) {
            return cwd;
        }
    }
    
    // --- 新增：事件总线（EventBus）---
    static class EventBus {
        private final Path eventLogPath;
        
        public EventBus(Path eventLogPath) {
            this.eventLogPath = eventLogPath;
            try {
                Files.createDirectories(eventLogPath.getParent());
                if (!Files.exists(eventLogPath)) {
                    Files.writeString(eventLogPath, "");
                }
            } catch (IOException e) {
                throw new RuntimeException("Failed to create event bus", e);
            }
        }
        
        /**
         * 发出事件
         */
        public void emit(String event, Map<String, Object> task, 
                        Map<String, Object> worktree, String error) {
            Map<String, Object> payload = new LinkedHashMap<>();
            payload.put("event", event);
            payload.put("ts", System.currentTimeMillis() / 1000.0);
            payload.put("task", task != null ? task : Map.of());
            payload.put("worktree", worktree != null ? worktree : Map.of());
            
            if (error != null) {
                payload.put("error", error);
            }
            // 结构化事件：事件类型、时间戳、关联数据
            // 错误跟踪：支持记录操作失败信息
            
            try {
                String jsonLine = gson.toJson(payload) + "\n";
                Files.writeString(eventLogPath, jsonLine, 
                    StandardOpenOption.CREATE, StandardOpenOption.APPEND);
                // JSONL格式：每行一个事件，便于流式处理
                // 追加写入：支持长时间运行的事件记录
            } catch (IOException e) {
                System.err.println("Failed to emit event: " + e.getMessage());
            }
        }
        
        /**
         * 列出最近事件
         */
        public String listRecent(int limit) {
            int n = Math.max(1, Math.min(limit, 200));
            
            try {
                List<String> lines = Files.readAllLines(eventLogPath);
                List<Map<String, Object>> events = new ArrayList<>();
                
                int start = Math.max(0, lines.size() - n);
                for (int i = start; i < lines.size(); i++) {
                    try {
                        Type type = new TypeToken<Map<String, Object>>(){}.getType();
                        Map<String, Object> event = gson.fromJson(lines.get(i), type);
                        events.add(event);
                    } catch (Exception e) {
                        Map<String, Object> errorEvent = new HashMap<>();
                        errorEvent.put("event", "parse_error");
                        errorEvent.put("raw", lines.get(i));
                        events.add(errorEvent);
                        // 容错处理：即使解析失败也记录原始数据
                    }
                }
                
                return gson.toJson(events);
            } catch (IOException e) {
                return "[]";
            }
        }
    }
    
    // 初始化事件总线
    private static final EventBus EVENTS = new EventBus(EVENTS_LOG_PATH);
    
    // --- 新增：任务管理器（支持工作树绑定）---
    static class TaskManager {
        private final Path tasksDir;
        private int nextId = 1;
        
        public TaskManager(Path tasksDir) {
            this.tasksDir = tasksDir;
            try {
                Files.createDirectories(tasksDir);
                this.nextId = getMaxId() + 1;
            } catch (IOException e) {
                throw new RuntimeException("Failed to initialize task manager", e);
            }
        }
        
        /**
         * 绑定任务到工作树
         */
        public String bindWorktree(int taskId, String worktree, String owner) throws IOException {
            Map<String, Object> task = loadTask(taskId);
            task.put("worktree", worktree);
            // 任务-工作树关联：建立任务和工作树的双向链接
            
            if (owner != null && !owner.isEmpty()) {
                task.put("owner", owner);
            }
            
            if ("pending".equals(task.get("status"))) {
                task.put("status", "in_progress");
                // 状态自动转换：绑定工作树时自动开始任务
            }
            
            task.put("updated_at", System.currentTimeMillis() / 1000.0);
            saveTask(task);
            return gson.toJson(task);
        }
        
        /**
         * 解绑工作树
         */
        public String unbindWorktree(int taskId) throws IOException {
            Map<String, Object> task = loadTask(taskId);
            task.put("worktree", "");
            task.put("updated_at", System.currentTimeMillis() / 1000.0);
            saveTask(task);
            return gson.toJson(task);
            // 解绑机制：支持任务和工作树的解耦
        }
        
        /**
         * 列出所有任务
         */
        public String listAllTasks() throws IOException {
            // ... 列出任务逻辑，包含工作树绑定信息
            sb.append(String.format("%s #%d: %s%s%s\n", 
                marker, id, subject, ownerStr, worktreeStr));
            // 可视化展示：显示任务状态、所有者、工作树绑定
        }
    }
    
    // 初始化任务管理器
    private static final TaskManager TASKS = new TaskManager(TASKS_DIR);
    
    // --- 新增：工作树管理器（WorktreeManager）---
    static class WorktreeManager {
        private final Path repoRoot;
        private final TaskManager taskManager;
        private final EventBus eventBus;
        private final Path worktreesDir;
        private final Path indexPath;
        private final boolean gitAvailable;
        
        public WorktreeManager(Path repoRoot, TaskManager taskManager, EventBus eventBus) {
            this.repoRoot = repoRoot;
            this.taskManager = taskManager;
            this.eventBus = eventBus;
            this.worktreesDir = repoRoot.resolve(".worktrees");
            this.indexPath = worktreesDir.resolve("index.json");
            // 集成架构：工作树管理器与任务管理器、事件总线集成
            
            try {
                Files.createDirectories(worktreesDir);
                if (!Files.exists(indexPath)) {
                    Map<String, Object> index = new HashMap<>();
                    index.put("worktrees", new ArrayList<Map<String, Object>>());
                    Files.writeString(indexPath, gson.toJson(index));
                }
            } catch (IOException e) {
                throw new RuntimeException("Failed to initialize worktree manager", e);
            }
            
            this.gitAvailable = isGitRepo();
        }
        
        /**
         * 检查是否是Git仓库
         */
        private boolean isGitRepo() {
            try {
                ProcessBuilder pb = new ProcessBuilder("git", "rev-parse", "--is-inside-work-tree");
                pb.directory(repoRoot.toFile());
                Process process = pb.start();
                return process.exitValue() == 0;
            } catch (Exception e) {
                return false;
            }
        }
        
        /**
         * 执行Git命令
         */
        private String runGit(List<String> args) throws Exception {
            if (!gitAvailable) {
                throw new RuntimeException("Not in a git repository. worktree tools require git.");
            }
            
            ProcessBuilder pb = new ProcessBuilder("git");
            pb.command().addAll(args);
            pb.directory(repoRoot.toFile());
            
            Process process = pb.start();
            boolean finished = process.waitFor(120, TimeUnit.SECONDS);
            
            if (!finished) {
                process.destroy();
                throw new RuntimeException("git command timeout");
            }
            
            int exitCode = process.exitValue();
            if (exitCode != 0) {
                String error = new String(process.getErrorStream().readAllBytes()).trim();
                String output = new String(process.getInputStream().readAllBytes()).trim();
                String message = error.isEmpty() ? output : error;
                if (message.isEmpty()) {
                    message = "git " + String.join(" ", args) + " failed";
                }
                throw new RuntimeException(message);
            }
            
            String output = new String(process.getInputStream().readAllBytes()).trim();
            String error = new String(process.getErrorStream().readAllBytes()).trim();
            String result = output + (error.isEmpty() ? "" : "\n" + error);
            return result.isEmpty() ? "(no output)" : result;
        }
        
        /**
         * 加载索引文件
         */
        @SuppressWarnings("unchecked")
        private Map<String, Object> loadIndex() throws IOException {
            String content = Files.readString(indexPath);
            Type type = new TypeToken<Map<String, Object>>(){}.getType();
            return gson.fromJson(content, type);
        }
        
        /**
         * 保存索引文件
         */
        private void saveIndex(Map<String, Object> index) throws IOException {
            Files.writeString(indexPath, gson.toJson(index));
        }
        
        /**
         * 验证工作树名称
         */
        private void validateName(String name) {
            if (name == null || name.isEmpty() || name.length() > 40) {
                throw new IllegalArgumentException("Worktree name must be 1-40 characters");
            }
            
            if (!name.matches("[A-Za-z0-9._-]+")) {
                throw new IllegalArgumentException(
                    "Invalid worktree name. Use letters, numbers, ., _, - only"
                );
            }
            // 名称规范：确保工作树名称安全且规范
        }
        
        /**
         * 创建工作树
         */
        public String createWorktree(String name, Integer taskId, String baseRef) throws Exception {
            validateName(name);
            
            Map<String, Object> existing = findWorktree(name);
            if (existing != null) {
                throw new IllegalArgumentException("Worktree '" + name + "' already exists");
            }
            
            if (taskId != null && !taskManager.taskExists(taskId)) {
                throw new IllegalArgumentException("Task " + taskId + " not found");
            }
            
            // 发出创建前事件
            Map<String, Object> taskInfo = taskId != null ? 
                Map.of("id", taskId) : Map.of();
            Map<String, Object> worktreeInfo = Map.of("name", name, "base_ref", baseRef);
            eventBus.emit("worktree.create.before", taskInfo, worktreeInfo, null);
            
            try {
                Path worktreePath = worktreesDir.resolve(name);
                String branch = "wt/" + name;  // 自动生成分支名
                
                // Git工作树创建
                runGit(Arrays.asList("worktree", "add", "-b", branch, 
                    worktreePath.toString(), baseRef));
                // Git工作树：独立的代码工作目录
                // 自动分支：为每个工作树创建独立分支
                
                // 创建索引条目
                Map<String, Object> entry = new LinkedHashMap<>();
                entry.put("name", name);
                entry.put("path", worktreePath.toString());
                entry.put("branch", branch);
                entry.put("task_id", taskId);
                entry.put("status", "active");
                entry.put("created_at", System.currentTimeMillis() / 1000.0);
                
                // 保存到索引
                Map<String, Object> index = loadIndex();
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> worktrees = (List<Map<String, Object>>) index.get("worktrees");
                worktrees.add(entry);
                saveIndex(index);
                
                // 绑定任务
                if (taskId != null) {
                    taskManager.bindWorktree(taskId, name, "");
                }
                
                // 发出创建后事件
                Map<String, Object> worktreeAfter = new LinkedHashMap<>();
                worktreeAfter.put("name", name);
                worktreeAfter.put("path", worktreePath.toString());
                worktreeAfter.put("branch", branch);
                worktreeAfter.put("status", "active");
                
                eventBus.emit("worktree.create.after", taskInfo, worktreeAfter, null);
                
                return gson.toJson(entry);
                
            } catch (Exception e) {
                eventBus.emit("worktree.create.failed", taskInfo, 
                    Map.of("name", name, "base_ref", baseRef), e.getMessage());
                throw e;
            }
        }
        
        /**
         * 获取工作树状态
         */
        public String getWorktreeStatus(String name) throws IOException {
            Map<String, Object> worktree = findWorktree(name);
            if (worktree == null) {
                return "Error: Unknown worktree '" + name + "'";
            }
            
            Path worktreePath = Paths.get((String) worktree.get("path"));
            if (!Files.exists(worktreePath)) {
                return "Error: Worktree path missing: " + worktreePath;
            }
            
            try {
                ProcessBuilder pb = new ProcessBuilder("git", "status", "--short", "--branch");
                pb.directory(worktreePath.toFile());
                
                Process process = pb.start();
                boolean finished = process.waitFor(60, TimeUnit.SECONDS);
                
                if (!finished) {
                    process.destroy();
                    return "Error: Git status timeout";
                }
                
                String output = new String(process.getInputStream().readAllBytes()).trim();
                String error = new String(process.getErrorStream().readAllBytes()).trim();
                String result = output + (error.isEmpty() ? "" : "\n" + error);
                
                return result.isEmpty() ? "Clean worktree" : result;
                // Git状态检查：提供详细的工作树状态信息
                
            } catch (Exception e) {
                return "Error: " + e.getMessage();
            }
        }
        
        /**
         * 在工作树中运行命令
         */
        public String runInWorktree(String name, String command) throws Exception {
            // 安全检查
            String[] dangerous = {"rm -rf /", "sudo", "shutdown", "reboot", "> /dev/"};
            for (String d : dangerous) {
                if (command.contains(d)) {
                    return "Error: Dangerous command blocked";
                }
            }
            
            Map<String, Object> worktree = findWorktree(name);
            if (worktree == null) {
                return "Error: Unknown worktree '" + name + "'";
            }
            
            Path worktreePath = Paths.get((String) worktree.get("path"));
            if (!Files.exists(worktreePath)) {
                return "Error: Worktree path missing: " + worktreePath;
            }
            
            try {
                ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
                pb.directory(worktreePath.toFile());
                // 目录隔离：命令在工作树的独立目录中执行
                
                Process process = pb.start();
                boolean finished = process.waitFor(300, TimeUnit.SECONDS);
                
                if (!finished) {
                    process.destroy();
                    return "Error: Timeout (300s)";
                }
                
                String output = new String(process.getInputStream().readAllBytes()).trim();
                String error = new String(process.getErrorStream().readAllBytes()).trim();
                String result = output + (error.isEmpty() ? "" : "\n" + error);
                
                return result.isEmpty() ? "(no output)" : 
                    result.substring(0, Math.min(result.length(), 50000));
                
            } catch (Exception e) {
                return "Error: " + e.getMessage();
            }
        }
        
        /**
         * 删除工作树
         */
        public String removeWorktree(String name, boolean force, boolean completeTask) throws Exception {
            Map<String, Object> worktree = findWorktree(name);
            if (worktree == null) {
                return "Error: Unknown worktree '" + name + "'";
            }
            
            // 发出删除前事件
            Integer taskId = (Integer) worktree.get("task_id");
            Map<String, Object> taskInfo = taskId != null ? 
                Map.of("id", taskId) : Map.of();
            Map<String, Object> worktreeInfo = Map.of(
                "name", name, 
                "path", worktree.get("path")
            );
            
            eventBus.emit("worktree.remove.before", taskInfo, worktreeInfo, null);
            
            try {
                List<String> args = new ArrayList<>();
                args.addAll(Arrays.asList("worktree", "remove"));
                if (force) {
                    args.add("--force");
                }
                args.add((String) worktree.get("path"));
                
                runGit(args);
                // Git工作树删除：清理Git工作树
                
                // 完成任务
                if (completeTask && taskId != null) {
                    Map<String, Object> task = gson.fromJson(taskManager.getTask(taskId), 
                        new TypeToken<Map<String, Object>>(){}.getType());
                    
                    taskManager.updateTask(taskId, "completed", null);
                    taskManager.unbindWorktree(taskId);
                    // 任务-工作树生命周期协同：删除工作树时自动完成任务
                    
                    Map<String, Object> taskEvent = new HashMap<>();
                    taskEvent.put("id", taskId);
                    taskEvent.put("subject", task.get("subject"));
                    taskEvent.put("status", "completed");
                    
                    eventBus.emit("task.completed", taskEvent, 
                        Map.of("name", name), null);
                }
                
                // 更新索引
                Map<String, Object> index = loadIndex();
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> worktrees = (List<Map<String, Object>>) index.get("worktrees");
                
                for (Map<String, Object> wt : worktrees) {
                    if (name.equals(wt.get("name"))) {
                        wt.put("status", "removed");
                        wt.put("removed_at", System.currentTimeMillis() / 1000.0);
                        break;
                    }
                }
                saveIndex(index);
                // 索引更新：标记工作树为已删除状态
                
                // 发出删除后事件
                Map<String, Object> worktreeAfter = new HashMap<>();
                worktreeAfter.put("name", name);
                worktreeAfter.put("path", worktree.get("path"));
                worktreeAfter.put("status", "removed");
                
                eventBus.emit("worktree.remove.after", taskInfo, worktreeAfter, null);
                
                return "Removed worktree '" + name + "'";
                
            } catch (Exception e) {
                eventBus.emit("worktree.remove.failed", taskInfo, worktreeInfo, e.getMessage());
                throw e;
            }
        }
        
        /**
         * 保留工作树（标记为保留状态）
         */
        public String keepWorktree(String name) throws IOException {
            Map<String, Object> worktree = findWorktree(name);
            if (worktree == null) {
                return "Error: Unknown worktree '" + name + "'";
            }
            
            Map<String, Object> index = loadIndex();
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> worktrees = (List<Map<String, Object>>) index.get("worktrees");
            
            Map<String, Object> keptWorktree = null;
            
            for (Map<String, Object> wt : worktrees) {
                if (name.equals(wt.get("name"))) {
                    wt.put("status", "kept");
                    wt.put("kept_at", System.currentTimeMillis() / 1000.0);
                    keptWorktree = wt;
                    break;
                }
            }
            
            saveIndex(index);
            // 保留状态：标记工作树为需要保留，不自动清理
            
            // 发出保留事件
            Integer taskId = (Integer) worktree.get("task_id");
            Map<String, Object> taskInfo = taskId != null ? 
                Map.of("id", taskId) : Map.of();
            
            Map<String, Object> worktreeInfo = new HashMap<>();
            worktreeInfo.put("name", name);
            worktreeInfo.put("path", worktree.get("path"));
            worktreeInfo.put("status", "kept");
            
            eventBus.emit("worktree.keep", taskInfo, worktreeInfo, null);
            
            return keptWorktree != null ? gson.toJson(keptWorktree) : 
                "Error: Unknown worktree '" + name + "'";
        }
    }
    
    // 初始化工作树管理器
    private static final WorktreeManager WORKTREES = new WorktreeManager(REPO_ROOT, TASKS, EVENTS);
    
    // --- 新增：工具处理器 ---
    static {
        // 新增任务工具
        TOOL_HANDLERS.put("task_create", args -> {
            String subject = (String) args.get("subject");
            String description = (String) args.get("description");
            return TASKS.createTask(subject, description);
        });
        
        TOOL_HANDLERS.put("task_list", args -> TASKS.listAllTasks());
        
        TOOL_HANDLERS.put("task_get", args -> {
            int taskId = ((Number) args.get("task_id")).intValue();
            return TASKS.getTask(taskId);
        });
        
        TOOL_HANDLERS.put("task_update", args -> {
            int taskId = ((Number) args.get("task_id")).intValue();
            String status = (String) args.get("status");
            String owner = (String) args.get("owner");
            return TASKS.updateTask(taskId, status, owner);
        });
        
        TOOL_HANDLERS.put("task_bind_worktree", args -> {
            int taskId = ((Number) args.get("task_id")).intValue();
            String worktree = (String) args.get("worktree");
            String owner = (String) args.get("owner");
            return TASKS.bindWorktree(taskId, worktree, owner);
        });
        
        // 新增工作树工具
        TOOL_HANDLERS.put("worktree_create", args -> {
            String name = (String) args.get("name");
            Integer taskId = args.get("task_id") != null ? 
                ((Number) args.get("task_id")).intValue() : null;
            String baseRef = (String) args.get("base_ref");
            if (baseRef == null) baseRef = "HEAD";
            return WORKTREES.createWorktree(name, taskId, baseRef);
        });
        
        TOOL_HANDLERS.put("worktree_list", args -> WORKTREES.listWorktrees());
        
        TOOL_HANDLERS.put("worktree_status", args -> {
            String name = (String) args.get("name");
            return WORKTREES.getWorktreeStatus(name);
        });
        
        TOOL_HANDLERS.put("worktree_run", args -> {
            String name = (String) args.get("name");
            String command = (String) args.get("command");
            return WORKTREES.runInWorktree(name, command);
        });
        
        TOOL_HANDLERS.put("worktree_keep", args -> {
            String name = (String) args.get("name");
            return WORKTREES.keepWorktree(name);
        });
        
        TOOL_HANDLERS.put("worktree_remove", args -> {
            String name = (String) args.get("name");
            boolean force = args.get("force") != null && (Boolean) args.get("force");
            boolean completeTask = args.get("complete_task") != null && (Boolean) args.get("complete_task");
            return WORKTREES.removeWorktree(name, force, completeTask);
        });
        
        TOOL_HANDLERS.put("worktree_events", args -> {
            int limit = args.get("limit") != null ? ((Number) args.get("limit")).intValue() : 20;
            return EVENTS.listRecent(limit);
        });
    }
    
    // --- 新增：工具定义 ---
    private static List<Map<String, Object>> getToolSpecs() {
        List<Map<String, Object>> tools = new ArrayList<>();
        
        // 任务工具定义...
        
        // 工作树工具定义...
        
        return tools;
    }
}

这段代码引入了工作树任务隔离系统，实现了：

1. 目录级隔离：每个任务在自己的工作树中执行
2. 控制平面与执行平面分离：
   • 控制平面：任务管理（.tasks/）
   • 执行平面：工作树管理（.worktrees/）
3. 事件总线：记录完整生命周期事件
4. Git 工作树集成：利用 git worktree 实现隔离

关键洞察：通过目录隔离并行任务，通过任务ID进行协调。

Git工作树隔离架构

核心思想：从文件系统隔离升级为Git仓库级别的代码隔离，通过Git工作树实现完全隔离的并行开发环境，为每个任务提供独立的代码工作空间，避免冲突，支持真正的并行开发。

// 核心路径配置
private static final Path REPO_ROOT = detectRepoRoot(WORKDIR);  // Git仓库根目录
private static final Path WORKTREES_DIR = REPO_ROOT.resolve(".worktrees");  // 工作树目录
// Git仓库感知：自动检测Git仓库根目录
// 工作树管理：专门的工作树存储目录
// 版本控制集成：与Git深度集成

// Git仓库检测
private static Path detectRepoRoot(Path cwd) {
    try {
        ProcessBuilder pb = new ProcessBuilder("git", "rev-parse", "--show-toplevel");
        pb.directory(cwd.toFile());
        Process process = pb.start();
        
        String output = new String(process.getInputStream().readAllBytes()).trim();
        Path root = Paths.get(output);
        return Files.exists(root) ? root : cwd;
        // 自动发现：自动定位Git仓库根目录
        // 兼容处理：非Git仓库时回退到当前目录
    } catch (Exception e) {
        return cwd;
    }
}

• Git原生集成：深度集成Git版本控制系统
• 仓库感知：自动识别和适应Git仓库结构
• 向后兼容：非Git环境也能工作
• 专业级隔离：为专业软件开发设计

工作树管理系统

// 工作树管理器核心
static class WorktreeManager {
    private final Path repoRoot;
    private final TaskManager taskManager;
    private final EventBus eventBus;
    private final Path worktreesDir;
    private final Path indexPath;
    private final boolean gitAvailable;
    // 三组件集成：仓库、任务、事件总线
    // 索引管理：工作树元数据索引
    // 可用性检查：检测Git环境
}

• 集成架构：与任务管理和事件系统深度集成
• 元数据管理：工作树元数据集中管理
• 环境感知：自动检测和适应Git环境
• 专业级管理：企业级的工作树生命周期管理

Git工作树创建机制

// 创建工作树
public String createWorktree(String name, Integer taskId, String baseRef) throws Exception {
    validateName(name);
    
    Path worktreePath = worktreesDir.resolve(name);
    String branch = "wt/" + name;  // 自动生成分支名
    
    // Git工作树创建
    runGit(Arrays.asList("worktree", "add", "-b", branch, 
        worktreePath.toString(), baseRef));
    // Git工作树：独立的工作目录
    // 自动分支：为每个工作树创建独立分支
    
    // 创建索引条目
    Map<String, Object> entry = new LinkedHashMap<>();
    entry.put("name", name);
    entry.put("path", worktreePath.toString());
    entry.put("branch", branch);
    entry.put("task_id", taskId);
    entry.put("status", "active");
    entry.put("created_at", System.currentTimeMillis() / 1000.0);
    // 完整元数据：名称、路径、分支、关联任务
    // 状态管理：明确的工作树生命周期状态
    
    // 保存到索引
    Map<String, Object> index = loadIndex();
    @SuppressWarnings("unchecked")
    List<Map<String, Object>> worktrees = (List<Map<String, Object>>) index.get("worktrees");
    worktrees.add(entry);
    saveIndex(index);
    // 索引管理：集中式工作树元数据管理
    // 持久化：工作树信息持久化存储
}

• Git原生：使用Git工作树实现真正的代码隔离
• 自动分支：为每个工作树自动创建分支
• 元数据完整：完整的工作树元数据记录
• 持久化索引：工作树信息持久化存储
• 状态管理：明确的工作树生命周期状态

任务-工作树双向绑定

// 任务管理器中的工作树绑定
public String bindWorktree(int taskId, String worktree, String owner) throws IOException {
    Map<String, Object> task = loadTask(taskId);
    task.put("worktree", worktree);
    // 双向绑定：任务记录工作树，工作树记录任务
    // 关联管理：建立任务和工作树的一对一关系
    
    if (owner != null && !owner.isEmpty()) {
        task.put("owner", owner);
    }
    
    if ("pending".equals(task.get("status"))) {
        task.put("status", "in_progress");
        // 状态自动转换：绑定工作树时自动开始任务
        // 工作流优化：简化任务启动流程
    }
    
    task.put("updated_at", System.currentTimeMillis() / 1000.0);
    saveTask(task);
    return gson.toJson(task);
}

// 工作树管理器中的任务绑定
if (taskId != null) {
    taskManager.bindWorktree(taskId, name, "");
    // 协同绑定：创建工作树时自动绑定任务
    // 双向同步：确保任务和工作树状态一致
}

• 双向关联：任务和工作树相互引用
• 状态协同：任务和工作树状态自动同步
• 工作流简化：自动的状态转换和绑定
• 数据一致性：确保关联数据的一致性

工作树操作隔离

// 在工作树中运行命令
public String runInWorktree(String name, String command) throws Exception {
    Map<String, Object> worktree = findWorktree(name);
    Path worktreePath = Paths.get((String) worktree.get("path"));
    
    try {
        ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
        pb.directory(worktreePath.toFile());
        // 目录隔离：命令在工作树的独立目录中执行
        // 环境隔离：每个工作树有自己的Git环境
        
        Process process = pb.start();
        boolean finished = process.waitFor(300, TimeUnit.SECONDS);
        
        String output = new String(process.getInputStream().readAllBytes()).trim();
        String error = new String(process.getErrorStream().readAllBytes()).trim();
        String result = output + (error.isEmpty() ? "" : "\n" + error);
        
        return result.isEmpty() ? "(no output)" : 
            result.substring(0, Math.min(result.length(), 50000));
        
    } catch (Exception e) {
        return "Error: " + e.getMessage();
    }
}

• 完全隔离：每个工作树是独立的文件系统目录
• Git环境隔离：每个工作树有自己的Git配置和历史
• 安全执行：命令在隔离环境中执行
• 结果返回：返回完整的命令执行结果

Git状态检查

// 获取工作树状态
public String getWorktreeStatus(String name) throws IOException {
    Path worktreePath = Paths.get((String) worktree.get("path"));
    
    try {
        ProcessBuilder pb = new ProcessBuilder("git", "status", "--short", "--branch");
        pb.directory(worktreePath.toFile());
        // Git状态：获取详细的工作树Git状态
        // 信息丰富：包括分支信息、变更状态等
        
        Process process = pb.start();
        boolean finished = process.waitFor(60, TimeUnit.SECONDS);
        
        String output = new String(process.getInputStream().readAllBytes()).trim();
        String error = new String(process.getErrorStream().readAllBytes()).trim();
        String result = output + (error.isEmpty() ? "" : "\n" + error);
        
        return result.isEmpty() ? "Clean worktree" : result;
        
    } catch (Exception e) {
        return "Error: " + e.getMessage();
    }
}

• Git专业：提供专业的Git状态信息
• 实时状态：实时检查工作树的Git状态
• 变更追踪：跟踪代码变更情况
• 问题诊断：便于诊断Git相关问题

工作树生命周期管理

// 删除工作树
public String removeWorktree(String name, boolean force, boolean completeTask) throws Exception {
    // Git工作树删除
    List<String> args = new ArrayList<>();
    args.addAll(Arrays.asList("worktree", "remove"));
    if (force) {
        args.add("--force");
    }
    args.add((String) worktree.get("path"));
    
    runGit(args);
    // Git清理：使用Git命令清理工作树
    // 选项支持：支持强制删除等选项
    
    // 完成任务
    if (completeTask && taskId != null) {
        taskManager.updateTask(taskId, "completed", null);
        taskManager.unbindWorktree(taskId);
        // 生命周期协同：删除工作树时自动完成任务
        // 状态清理：清理任务和工作树的关联
        
        Map<String, Object> taskEvent = new HashMap<>();
        taskEvent.put("id", taskId);
        taskEvent.put("subject", task.get("subject"));
        taskEvent.put("status", "completed");
        
        eventBus.emit("task.completed", taskEvent, 
            Map.of("name", name), null);
    }
    
    // 更新索引
    for (Map<String, Object> wt : worktrees) {
        if (name.equals(wt.get("name"))) {
            wt.put("status", "removed");
            wt.put("removed_at", System.currentTimeMillis() / 1000.0);
            break;
        }
    }
    saveIndex(index);
    // 状态更新：标记工作树为已删除状态
    // 历史保留：保留工作树的删除记录
}

• 完整生命周期：创建、使用、保留、删除的完整生命周期
• Git原生：使用Git命令管理工作树
• 任务协同：工作树删除时自动处理关联任务
• 状态管理：明确的工作树状态管理
• 历史追踪：保留工作树的历史记录

工作树保留机制

// 保留工作树
public String keepWorktree(String name) throws IOException {
    for (Map<String, Object> wt : worktrees) {
        if (name.equals(wt.get("name"))) {
            wt.put("status", "kept");
            wt.put("kept_at", System.currentTimeMillis() / 1000.0);
            keptWorktree = wt;
            break;
        }
    }
    saveIndex(index);
    // 保留状态：标记工作树为需要保留
    // 不自动清理：保留的工作树不会被自动清理
    // 时间戳记录：记录保留时间
}

• 选择性保留：可以保留有价值的工作树
• 长期存储：保留的工作树可以长期存在
• 状态明确：明确的保留状态标记
• 时间追踪：记录保留时间

事件总线集成

// 事件总线
static class EventBus {
    public void emit(String event, Map<String, Object> task, 
                    Map<String, Object> worktree, String error) {
        Map<String, Object> payload = new LinkedHashMap<>();
        payload.put("event", event);
        payload.put("ts", System.currentTimeMillis() / 1000.0);
        payload.put("task", task != null ? task : Map.of());
        payload.put("worktree", worktree != null ? worktree : Map.of());
        
        if (error != null) {
            payload.put("error", error);
        }
        // 结构化事件：标准的事件格式
        // 时间戳：精确的事件时间
        // 关联数据：关联的任务和工作树信息
        // 错误信息：支持错误事件记录
        
        String jsonLine = gson.toJson(payload) + "\n";
        Files.writeString(eventLogPath, jsonLine, 
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
        // JSONL格式：便于流式处理和分析
        // 追加写入：支持长时间运行的事件记录
    }
}

• 全面审计：所有工作树操作都有完整的事件记录
• 结构化日志：标准化的JSON事件格式
• 时间序列：精确的时间戳序列
• 错误追踪：完整的错误事件追踪
• 可分析性：便于后续的数据分析

架构演进与价值

从 AutonomousAgentsSystem 到 WorktreeTaskIsolationSystem 的升级：

总结

完结撒花。。。

总体来说，这个开源网站系统性地拆解了一个高级AI编程智能体的构建过程，展现了一条清晰的能力演进路径：从具备基础感知和执行能力的单一智能体（工具与执行），发展到能够进行内部规划、分解任务、调用外部知识的协调者（规划与协调），再升级为可以管理资源、并行处理、支撑长时对话的高效执行者（内存管理与并发），最终演化为一个角色分明、通信顺畅、协同作战的智能体团队（协作）。

这条路径揭示了一个核心范式：强大的AI Agent系统并非一蹴而就，可以说是通过不断叠加精心设计的、模块化的机制（如状态管理、上下文隔离、知识外挂、异步处理、消息传递）逐步构建而成。

每个阶段都解决了前一阶段遇到的关键瓶颈，最终将这些模块像积木一样组合，形成一个既可应对复杂项目开发，又能高效管理自身资源与协作的成熟智能体系统。这为我们构建自己的生产级AI Agent提供了宝贵的蓝图和实战指南。