第四章：Orchestrator 编排器

Orchestrator 是 OpenMatrix 的核心组件，负责任务调度、状态管理和流程控制。

4.1 Executor 主执行器

Executor 是编排层的中心控制器，协调所有其他组件。

核心接口

// orchestrator/executor.ts

interface Executor {
  /**
   * 主执行入口
   * @param input 用户输入的任务定义
   * @returns 执行结果
   */
  execute(input: TaskInput): Promise<ExecutionResult>;
  
  /**
   * 获取待执行的 SubagentTask 列表
   * 用于 Skills 调用 Agent tool
   */
  getSubagentTasks(): SubagentTask[];
  
  /**
   * 处理 Agent 执行完成
   * @param taskId 任务ID
   * @param result Agent 执行结果
   */
  handleTaskComplete(taskId: string, result: AgentResult): void;
  
  /**
   * 获取当前执行状态
   */
  getStatus(): ExecutionStatus;
}

执行流程图

flowchart TD
    subgraph "初始化阶段"
        A[execute 入口] --> B[创建 runId]
        B --> C[初始化 .openmatrix/]
        C --> D[生成 state.json]
    end
    
    subgraph "规划阶段"
        D --> E[调用 TaskPlanner]
        E --> F[AI 分析任务]
        F --> G[生成任务列表]
        G --> H[写入 tasks/*.json]
    end
    
    subgraph "调度阶段"
        H --> I[调用 Scheduler]
        I --> J[解析依赖关系]
        J --> K[按优先级排序]
        K --> L[标记 scheduled]
    end
    
    subgraph "执行阶段"
        L --> M{获取下一任务}
        M --> N[调用 PhaseExecutor]
        N --> O[生成 SubagentTask]
        O --> P[返回给 Skills]
        P --> Q[Agent 执行]
        Q --> R{执行结果}
        
        R --> |"成功"| S[handleTaskComplete]
        R --> |"阻塞"| T[创建 Meeting]
        R --> |"失败"| U[进入 retry_queue]
        
        S --> V{还有任务?}
        T --> V
        U --> V
        
        V --> |"有"| M
        V --> |"无"| W[生成报告]
    end
    
    subgraph "完成阶段"
        W --> X[Git 自动提交]
        X --> Y[返回 ExecutionResult]
    end

关键实现

class ExecutorImpl implements Executor {
  private scheduler: Scheduler;
  private phaseExecutor: PhaseExecutor;
  private meetingManager: MeetingManager;
  private stateManager: StateManager;
  
  async execute(input: TaskInput): Promise<ExecutionResult> {
    // 1. 初始化
    const runId = this.generateRunId();
    await this.stateManager.initialize(runId, input);
    
    // 2. 任务规划
    const tasks = await this.taskPlanner.plan(input);
    await this.stateManager.saveTasks(tasks);
    
    // 3. 调度
    await this.scheduler.scheduleAll(tasks);
    
    // 4. 执行循环
    while (this.scheduler.hasPendingTasks()) {
      const task = this.scheduler.getNextTask();
      if (!task) break;
      
      const subagentTask = await this.phaseExecutor.prepare(task);
      this.pendingTasks.push(subagentTask);
    }
    
    return {
      status: 'running',
      subagentTasks: this.pendingTasks
    };
  }
  
  handleTaskComplete(taskId: string, result: AgentResult): void {
    const task = this.stateManager.getTask(taskId);
    
    if (result.status === 'blocked') {
      this.meetingManager.createMeeting(taskId, result.blockInfo);
      this.stateManager.updateTaskStatus(taskId, 'waiting');
    } else if (result.status === 'success') {
      this.stateManager.updateTaskStatus(taskId, 'verify');
      // 进入验证阶段
    } else {
      this.stateManager.updateTaskStatus(taskId, 'failed');
    }
    
    // 继续调度
    this.continueExecution();
  }
}

ExecutionResult 结构

interface ExecutionResult {
  runId: string;
  status: 'running' | 'completed' | 'failed' | 'blocked';
  subagentTasks: SubagentTask[];
  statistics: {
    total: number;
    completed: number;
    failed: number;
    blocked: number;
  };
  report?: QualityReport;
}

4.2 Scheduler 调度器

Scheduler 管理任务的调度顺序和依赖关系。

核心接口

// orchestrator/scheduler.ts

interface Scheduler {
  /**
   * 获取下一个可执行任务
   * @returns 任务或 null（无可用任务）
   */
  getNextTask(): Task | null;
  
  /**
   * 调度所有任务
   * 设置初始状态和依赖关系
   */
  scheduleAll(tasks: Task[]): void;
  
  /**
   * 检查任务依赖是否满足
   */
  checkDependencies(taskId: string): boolean;
  
  /**
   * 检测是否存在循环依赖
   * @returns 循环依赖的任务ID列表
   */
  detectCircularDependency(): string[];
  
  /**
   * 检查是否有待执行任务
   */
  hasPendingTasks(): boolean;
}

调度算法

flowchart TD
    A[getNextTask] --> B[获取所有 scheduled 任务]
    B --> C[过滤依赖未满足的]
    C --> D[按优先级排序]
    D --> E[取最高优先级任务]
    
    E --> F{任务存在?}
    F --> |"是"| G[返回任务]
    F --> |"否"| H[返回 null]

依赖检查实现

class SchedulerImpl implements Scheduler {
  checkDependencies(taskId: string): boolean {
    const task = this.stateManager.getTask(taskId);
    
    for (const depId of task.dependencies) {
      const depTask = this.stateManager.getTask(depId);
      
      // 依赖任务必须已完成
      if (depTask.status !== 'completed') {
        return false;
      }
    }
    
    return true;
  }
  
  detectCircularDependency(): string[] {
    const visited = new Set<string>();
    const recursionStack = new Set<string>();
    const cycles: string[] = [];
    
    for (const task of this.getAllTasks()) {
      if (this.detectCycle(task.id, visited, recursionStack, cycles)) {
        return cycles;
      }
    }
    
    return [];
  }
  
  private detectCycle(
    taskId: string,
    visited: Set<string>,
    stack: Set<string>,
    cycles: string[]
  ): boolean {
    if (stack.has(taskId)) {
      cycles.push(taskId);
      return true;
    }
    
    if (visited.has(taskId)) {
      return false;
    }
    
    visited.add(taskId);
    stack.add(taskId);
    
    const task = this.stateManager.getTask(taskId);
    for (const depId of task.dependencies) {
      if (this.detectCycle(depId, visited, stack, cycles)) {
        cycles.push(taskId);
        return true;
      }
    }
    
    stack.delete(taskId);
    return false;
  }
}

优先级排序

class SchedulerImpl implements Scheduler {
  getNextTask(): Task | null {
    const scheduledTasks = this.stateManager
      .getTasksByStatus('scheduled')
      .filter(t => this.checkDependencies(t.id));
    
    if (scheduledTasks.length === 0) {
      return null;
    }
    
    // 按优先级降序排序
    scheduledTasks.sort((a, b) => b.priority - a.priority);
    
    return scheduledTasks[0];
  }
}

依赖图示例

graph TD
    T1["TASK-001<br/>priority: 10<br/>status: scheduled"] --> T2["TASK-002<br/>priority: 7"]
    T1 --> T3["TASK-003<br/>priority: 8"]
    T2 --> T4["TASK-004<br/>priority: 5"]
    T3 --> T5["TASK-005<br/>priority: 6"]
    T4 --> T6["TASK-006<br/>priority: 3"]
    T5 --> T6
    
    style T1 fill:#90EE90
    style T2 fill:#FFFACD
    style T3 fill:#FFFACD
    style T4 fill:#D3D3D3
    style T5 fill:#D3D3D3
    style T6 fill:#D3D3D3

执行顺序：

1. TASK-001（优先级最高，无依赖）
2. TASK-003（优先级 8）
3. TASK-002（优先级 7）
4. TASK-005（优先级 6）
5. TASK-004（优先级 5）
6. TASK-006（优先级最低，依赖多个）

4.3 StateMachine 状态机

StateMachine 定义任务状态的合法转换。

状态定义

// orchestrator/state-machine.ts

type TaskStatus =
  | 'pending'      // 初始状态
  | 'scheduled'    // 已调度，等待执行
  | 'in_progress'  // 正在执行
  | 'blocked'      // 阻塞中
  | 'waiting'      // 等待 Meeting
  | 'verify'       // 验证阶段
  | 'accept'       // 接收阶段
  | 'completed'    // 已完成
  | 'failed'       // 已失败
  | 'retry_queue'; // 待重试

状态转换图

stateDiagram-v2
    [*] --> pending: 创建
    
    pending --> scheduled: 依赖满足
    scheduled --> in_progress: 开始执行
    
    in_progress --> blocked: 需要外部信息
    blocked --> waiting: 创建 Meeting
    waiting --> scheduled: Meeting 解决
    
    in_progress --> verify: 开发完成
    verify --> accept: 质量门禁通过
    verify --> failed: 质量门禁失败
    
    accept --> completed: 审查通过
    accept --> failed: 审查失败
    
    failed --> retry_queue: 进入重试队列
    retry_queue --> scheduled: 重新调度
    
    completed --> [*]

转换规则表

interface StateMachine {
  // 状态转换规则
  transitions: Map<TaskStatus, TaskStatus[]>;
}

const TRANSITIONS: Map<TaskStatus, TaskStatus[]> = new Map([
  ['pending', ['scheduled']],
  ['scheduled', ['in_progress']],
  ['in_progress', ['blocked', 'verify']],
  ['blocked', ['waiting']],
  ['waiting', ['scheduled']],
  ['verify', ['accept', 'failed']],
  ['accept', ['completed', 'failed']],
  ['failed', ['retry_queue']],
  ['retry_queue', ['scheduled']],
  ['completed', []]  // 最终状态
]);

核心实现

class StateMachineImpl implements StateMachine {
  transition(taskId: string, newStatus: TaskStatus): void {
    const task = this.stateManager.getTask(taskId);
    const currentStatus = task.status;
    
    if (!this.isValidTransition(currentStatus, newStatus)) {
      throw new Error(
        `Invalid transition: ${currentStatus} → ${newStatus}`
      );
    }
    
    this.stateManager.updateTaskStatus(taskId, newStatus);
    
    // 记录状态历史
    this.logStateTransition(taskId, currentStatus, newStatus);
  }
  
  isValidTransition(from: TaskStatus, to: TaskStatus): boolean {
    const validTargets = TRANSITIONS.get(from) || [];
    return validTargets.includes(to);
  }
  
  getValidTransitions(currentStatus: TaskStatus): TaskStatus[] {
    return TRANSITIONS.get(currentStatus) || [];
  }
}

状态转换触发条件

4.4 PhaseExecutor 阶段执行器

PhaseExecutor 执行任务的四阶段流程。

四阶段流程

flowchart TD
    subgraph "strict 模式"
        A[TDD] --> B[Develop]
        B --> C[Verify]
        C --> D[Accept]
    end
    
    subgraph "balanced 模式"
        E[Develop] --> F[Verify]
        F --> G[Accept]
    end
    
    subgraph "fast 模式"
        H[Develop] --> I[完成]
    end

核心接口

// orchestrator/phase-executor.ts

type PhaseType = 'tdd' | 'develop' | 'verify' | 'accept';

interface PhaseExecutor {
  /**
   * 执行指定阶段
   */
  executePhase(taskId: string, phase: PhaseType): Promise<PhaseResult>;
  
  /**
   * 准备阶段执行配置
   */
  preparePhase(taskId: string, phase: PhaseType): SubagentTask;
  
  /**
   * 获取当前阶段
   */
  getCurrentPhase(taskId: string): PhaseType;
  
  /**
   * 确定下一阶段
   */
  getNextPhase(currentPhase: PhaseType, quality: QualityLevel): PhaseType | null;
}

PhaseResult 结构

interface PhaseResult {
  phase: PhaseType;
  status: 'success' | 'blocked' | 'failed';
  taskId: string;
  
  // 成功时
  artifacts?: string[];         // 生成的文件
  contextUpdate?: string;       // Agent Memory 更新
  
  // 阻塞时
  blockInfo?: BlockInfo;
  
  // 失败时
  error?: ErrorInfo;
  
  // Verify 阶段特有的质量报告
  qualityReport?: QualityReport;
}

阶段执行实现

class PhaseExecutorImpl implements PhaseExecutor {
  
  preparePhase(taskId: string, phase: PhaseType): SubagentTask {
    const task = this.stateManager.getTask(taskId);
    const context = this.readAgentContext(taskId);
    
    switch (phase) {
      case 'tdd':
        return {
          subagent_type: 'general-purpose',
          description: `Execute ${taskId} TDD phase`,
          prompt: this.buildTDDPrompt(task, context),
          taskId,
          agentType: 'tester',
          timeout: 300000,
          needsApproval: false
        };
        
      case 'develop':
        return {
          subagent_type: 'general-purpose',
          description: `Execute ${taskId} Develop phase`,
          prompt: this.buildDevelopPrompt(task, context),
          taskId,
          agentType: 'coder',
          timeout: 600000,
          needsApproval: false
        };
        
      case 'verify':
        return {
          subagent_type: 'general-purpose',
          description: `Execute ${taskId} Verify phase`,
          prompt: this.buildVerifyPrompt(task, context),
          taskId,
          agentType: 'executor',
          timeout: 300000,
          needsApproval: false
        };
        
      case 'accept':
        return {
          subagent_type: 'general-purpose',
          description: `Execute ${taskId} Accept phase`,
          prompt: this.buildAcceptPrompt(task, context),
          taskId,
          agentType: 'reviewer',
          timeout: 180000,
          needsApproval: false
        };
    }
  }
  
  getNextPhase(
    currentPhase: PhaseType,
    quality: QualityLevel
  ): PhaseType | null {
    if (quality === 'fast') {
      return null;  // fast 模式无后续阶段
    }
    
    if (quality === 'balanced') {
      const sequence: PhaseType[] = ['develop', 'verify', 'accept'];
      const idx = sequence.indexOf(currentPhase);
      return idx < sequence.length - 1 ? sequence[idx + 1] : null;
    }
    
    // strict 模式
    const sequence: PhaseType[] = ['tdd', 'develop', 'verify', 'accept'];
    const idx = sequence.indexOf(currentPhase);
    return idx < sequence.length - 1 ? sequence[idx + 1] : null;
  }
}

阶段 Prompt 构建

class PhaseExecutorImpl {
  
  buildTDDPrompt(task: Task, context: string): string {
    return `
# Task: ${task.title}
# Phase: TDD (Test-Driven Development)

## Task Description
${task.description}

## Context from Previous Agents
${context}

## Your Goal
Write comprehensive tests that:
1. Cover the expected functionality described above
2. Tests MUST FAIL currently (RED phase of TDD)
3. Include edge cases and error scenarios

## Requirements
- Test file should be placed in appropriate test directory
- Use the project's existing test framework
- Tests should be clear and well-structured

## Output
Create test files and report:
- Files created
- Test cases written
- Current test execution status (should be failing)
`;
  }
  
  buildDevelopPrompt(task: Task, context: string): string {
    return `
# Task: ${task.title}
# Phase: Develop (Implementation)

## Task Description
${task.description}

## Context from Previous Agents
${context}

## Existing Tests (from TDD phase)
Read the test files and understand what needs to be implemented.

## Your Goal
Implement the functionality that:
1. Passes all the tests written in TDD phase (GREEN)
2. Follows project coding standards
3. Is clean and maintainable

## Requirements
- All tests must pass after implementation
- Code should be well-structured
- Add necessary comments for complex logic

## Output
Create/modify implementation files and report:
- Files created/modified
- Key decisions made
- Suggestions for next phases
`;
  }
}

4.5 TaskPlanner 任务规划器

TaskPlanner 将用户指令拆解为可执行任务。

核心接口

// orchestrator/task-planner.ts

interface TaskPlanner {
  /**
   * 根据用户输入规划任务
   */
  plan(input: TaskInput): Promise<Task[]>;
  
  /**
   * 分析任务依赖关系
   */
  analyzeDependencies(tasks: Task[]): DependencyGraph;
  
  /**
   * 为任务分配 Agent
   */
  assignAgents(tasks: Task[]): void;
}

TaskInput 结构

interface TaskInput {
  // 用户原始指令
  instruction: string;
  
  // 目标描述
  goals: string[];
  
  // 约束条件
  constraints?: string[];
  
  // 交付物定义
  deliverables?: string[];
  
  // 上下文信息
  context?: {
    projectType?: string;
    techStack?: string[];
    existingCodebase?: boolean;
  };
}

规划流程

flowchart TD
    A[用户指令] --> B[AI 分析]
    B --> C[识别子任务]
    C --> D[估算复杂度]
    D --> E[分析依赖关系]
    E --> F[分配优先级]
    F --> G[分配 Agent]
    G --> H[生成 Task 对象]
    
    H --> I[TASK-001]
    H --> J[TASK-002]
    H --> K[TASK-003]
    H --> L[...]

依赖图构建

interface DependencyGraph {
  nodes: Map<string, Task>;
  edges: Map<string, string[]>;  // taskId -> dependent taskIds
}

class TaskPlannerImpl implements TaskPlanner {
  analyzeDependencies(tasks: Task[]): DependencyGraph {
    const graph: DependencyGraph = {
      nodes: new Map(),
      edges: new Map()
    };
    
    // 构建节点
    for (const task of tasks) {
      graph.nodes.set(task.id, task);
      graph.edges.set(task.id, []);
    }
    
    // 分析依赖关系
    for (const task of tasks) {
      for (const depId of task.dependencies) {
        const dependents = graph.edges.get(depId) || [];
        dependents.push(task.id);
        graph.edges.set(depId, dependents);
      }
    }
    
    return graph;
  }
}

AI 规划 Prompt

class TaskPlannerImpl {
  buildPlanPrompt(input: TaskInput): string {
    return `
# Task Planning Request

## User Instruction
${input.instruction}

## Goals
${input.goals.map(g => `- ${g}`).join('\n')}

## Constraints
${input.constraints?.map(c => `- ${c}`).join('\n') || 'None specified'}

## Deliverables
${input.deliverables?.map(d => `- ${d}`).join('\n') || 'To be determined'}

## Context
- Project Type: ${input.context?.projectType || 'Unknown'}
- Tech Stack: ${input.context?.techStack?.join(', ') || 'Unknown'}
- Existing Codebase: ${input.context?.existingCodebase ? 'Yes' : 'No'}

## Your Task
Break down this request into specific, actionable sub-tasks.

For each task, provide:
1. **id**: TASK-XXX format
2. **title**: Short, clear title
3. **description**: Detailed description of what to do
4. **dependencies**: List of task IDs this depends on
5. **priority**: 1-10 (higher = more important)
6. **estimatedComplexity**: low/medium/high
7. **agentType**: planner/coder/tester/reviewer/researcher/executor

## Output Format
Return a JSON array of tasks.
`;
  }
}

4.6 MeetingManager 阻塞管理器

MeetingManager 处理阻塞任务的记录和解决。

核心接口

// orchestrator/meeting-manager.ts

type MeetingType = 'information' | 'decision' | 'approval' | 'dependency';

interface Meeting {
  id: string;
  taskId: string;
  type: MeetingType;
  title: string;
  description: string;
  questions: Question[];
  status: 'pending' | 'resolved' | 'skipped';
  createdAt: string;
  resolvedAt?: string;
}

interface MeetingManager {
  createMeeting(taskId: string, blockInfo: BlockInfo): Meeting;
  getPendingMeetings(): Meeting[];
  resolveMeeting(meetingId: string, resolution: Resolution): void;
  skipMeeting(meetingId: string): void;
}

Meeting 创建流程

flowchart TD
    A[Agent 阻塞] --> B[返回 BlockInfo]
    B --> C[MeetingManager.createMeeting]
    C --> D[生成 Meeting ID]
    D --> E[分析阻塞类型]
    E --> F[生成问题列表]
    F --> G[写入 meetings/MEETING-XXX/]
    G --> H[任务状态 → waiting]

BlockInfo 结构

interface BlockInfo {
  reason: string;              // 阻塞原因
  type: MeetingType;           // 阻塞类型
  missingInfo?: string[];      // 缺少的信息
  options?: Option[];          // 可选方案（decision 类型）
  externalDependency?: string; // 外部依赖描述
}

interface Question {
  id: string;
  text: string;
  type: 'text' | 'choice' | 'boolean';
  options?: string[];          // 选择类型时提供
  required: boolean;
}

Meeting 解决处理

interface Resolution {
  meetingId: string;
  answers: Map<string, string>;  // 问题ID -> 答案
  decision?: 'skip' | 'retry';
}

class MeetingManagerImpl implements MeetingManager {
  resolveMeeting(meetingId: string, resolution: Resolution): void {
    const meeting = this.stateManager.getMeeting(meetingId);
    const task = this.stateManager.getTask(meeting.taskId);
    
    // 更新 Meeting 状态
    meeting.status = 'resolved';
    meeting.resolvedAt = new Date().toISOString();
    
    // 写入解决方案
    this.fileStore.writeJson(
      `.openmatrix/meetings/${meetingId}/resolution.json`,
      resolution
    );
    
    // 更新任务状态
    this.stateManager.updateTaskStatus(task.id, 'scheduled');
    
    // 触发重新调度
    this.scheduler.reschedule(task.id);
  }
}

4.7 ApprovalManager 审批管理器

ApprovalManager 管理需要用户确认的审批流程。

审批类型

type ApprovalType = 'plan' | 'merge' | 'deploy' | 'meeting';

interface Approval {
  id: string;
  type: ApprovalType;
  content: any;
  status: 'pending' | 'approved' | 'rejected';
  createdAt: string;
  processedAt?: string;
}

核心接口

// orchestrator/approval-manager.ts

interface ApprovalManager {
  createApproval(type: ApprovalType, content: any): Approval;
  getPendingApprovals(): Approval[];
  processApproval(
    approvalId: string,
    decision: 'approve' | 'reject'
  ): void;
}

审批触发时机

审批流程

flowchart TD
    A[触发审批点] --> B[ApprovalManager.createApproval]
    B --> C[写入 approvals/]
    C --> D{执行模式}
    
    D --> |"interactive"| E[暂停等待用户]
    D --> |"semi-auto"| F{关键审批?}
    F --> |"是"| E
    F --> |"否"| G[自动批准]
    D --> |"full-auto"| G
    
    E --> H{用户决策}
    H --> |"批准"| I[processApproval approve]
    H --> |"拒绝"| J[processApproval reject]
    
    G --> I
    
    I --> K[继续执行]
    J --> L[调整流程]

4.8 RetryManager 重试管理器

RetryManager 管理失败任务的重试策略。

核心接口

// orchestrator/retry-manager.ts

interface RetryManager {
  /**
   * 将失败任务加入重试队列
   */
  addToRetryQueue(taskId: string, error: ErrorInfo): void;
  
  /**
   * 获取待重试任务
   */
  getRetryQueueTasks(): Task[];
  
  /**
   * 执行重试
   */
  executeRetry(taskId: string): Promise<void>;
  
  /**
   * 检查是否应该放弃重试
   */
  shouldAbandon(taskId: string): boolean;
}

重试策略

interface RetryPolicy {
  maxRetries: number;          // 最大重试次数（默认 3）
  backoffStrategy: 'linear' | 'exponential';
  baseDelay: number;           // 基础延迟（ms）
  maxDelay: number;            // 最大延迟（ms）
}

const DEFAULT_POLICY: RetryPolicy = {
  maxRetries: 3,
  backoffStrategy: 'exponential',
  baseDelay: 1000,
  maxDelay: 30000
};

重试流程

flowchart TD
    A[任务失败] --> B[RetryManager.addToRetryQueue]
    B --> C[记录失败原因]
    C --> D[计算延迟]
    D --> E[等待延迟时间]
    E --> F[状态 → scheduled]
    F --> G[重新执行]
    
    G --> H{执行结果}
    H --> |"成功"| I[完成]
    H --> |"失败"| J{重试次数}
    J --> |"< maxRetries"| B
    J --> |">= maxRetries"| K[放弃任务]

延迟计算

class RetryManagerImpl implements RetryManager {
  calculateDelay(retryCount: number): number {
    const policy = this.getRetryPolicy();
    
    if (policy.backoffStrategy === 'linear') {
      return Math.min(
        policy.baseDelay * retryCount,
        policy.maxDelay
      );
    }
    
    // exponential
    return Math.min(
      policy.baseDelay * Math.pow(2, retryCount - 1),
      policy.maxDelay
    );
  }
  
  shouldAbandon(taskId: string): boolean {
    const task = this.stateManager.getTask(taskId);
    const retryCount = task.retryCount || 0;
    return retryCount >= this.policy.maxRetries;
  }
}

4.9 GitCommitManager 自动提交

GitCommitManager 在任务完成后自动提交代码。

核心接口

// orchestrator/git-commit-manager.ts

interface GitCommitManager {
  /**
   * 提交完成的任务
   */
  commitTask(taskId: string): Promise<void>;
  
  /**
   * 生成 commit 信息
   */
  generateCommitMessage(task: Task): string;
  
  /**
   * 检查是否有未提交变更
   */
  hasUncommittedChanges(): boolean;
}

Commit 格式

<type>(TASK-XXX): Short description

Change 1
Change 2

Impact scope: Module name
Files changed: file1, file2

Co-Authored-By: OpenMatrix https://github.com/bigfish1913/openmatrix

Commit Types:

• feat: 新功能
• fix: Bug 修复
• test: 测试相关
• refactor: 重构
• docs: 文档

提交流程

flowchart TD
    A[任务完成] --> B[检查文件变更]
    B --> C{有变更?}
    C --> |"有"| D[生成 commit 信息]
    C --> |"无"| E[跳过提交]
    
    D --> F[git add]
    F --> G[git commit]
    G --> H[记录 commit hash]
    H --> I[更新任务状态]

下一章将深入探讨 Agent 系统 的设计与实现。