第97章　任务系统

任务系统是 SAI Individual 从“持续运行”进入“有组织地执行多个工作”的重要机制。

前面的 State Machine 解决的是：

状态如何变化？

而任务系统解决的是：

现在有什么事情要做？先做什么？由谁执行？执行结果是什么？

因此，Task System 位于 Individual、Behavior、Action、Engine、Event、State Machine 之间，负责把需要完成的工作组织成可执行任务。

1. Task

1.1 Task 定义

Task（任务）是 SAI Individual 对一个明确目标或工作事项的结构化描述。

可以定义为：

Task = Target + Goal + Condition + Actions + Priority + State + Result

任务不是一个简单的方法调用，而是一个具有生命周期的执行对象。

例如：

Task_A
目标：降低 Vehicle_A 当前速度
对象：Vehicle_A
条件：
    当前速度 > 30
    前方存在风险
任务：
    将速度降低到 20
优先级：HIGH
状态：READY

1.2 Task 基本结构

Task
├── Identity
├── Target
├── Goal
├── Condition
├── Actions
├── Priority
├── State
├── Dependencies
├── Result
├── Source
├── CreatedAt
└── UpdatedAt

可以表示为：

{
    "id": "Task_A",
    "type": "VEHICLE_CONTROL",
    "target": "Vehicle_A",
    "goal": "DECELERATE",
    "condition": {
        "speed": {
            "operator": ">",
            "value": 30
        }
    },
    "actions": [
        {
            "type": "SET_SPEED",
            "value": 20
        }
    ],
    "priority": 90,
    "state": "READY"
}

1.3 Task 与 Action 的区别

这是任务系统中的重要边界。

Task
 ↓
Behavior
 ↓
Action

例如：

Task：
降低车辆速度

Behavior：
执行减速过程

Action：
SET_SPEED = 20

因此：

Task 是工作目标。

Behavior 是任务执行过程。

Action 是具体执行操作。

2. Task Queue

2.1 Task Queue 定义

Task Queue（任务队列）负责保存等待执行的 Task。

基本结构：

Task
 ↓
Task Queue
 ↓
Task Executor

例如 Individual 当前收到多个任务：

Task_A：处理传感器信息
Task_B：检查设备状态
Task_C：执行减速
Task_D：保存经验

Task Queue：

┌──────────────┐
│ Task_A       │
│ Task_B       │
│ Task_C       │
│ Task_D       │
└──────────────┘

Executor 从队列中选择任务执行。

2.2 FIFO Queue

最简单的任务队列采用 FIFO：

First In
   ↓
First Out

例如：

加入：
Task_A
Task_B
Task_C

执行：
Task_A
Task_B
Task_C

适用于没有明显优先级差异的普通任务。

2.3 Priority Queue

SAI Individual 通常需要考虑任务优先级，因此可以使用 Priority Queue。

例如：

Task_A  priority=30
Task_B  priority=90
Task_C  priority=60

执行顺序：

Task_B
 ↓
Task_C
 ↓
Task_A

因此：

Task Queue
    ↓
Priority
    ↓
Task Selection
    ↓
Task Executor

2.4 Task Queue 的基本操作

enqueue(Task)

加入任务。

dequeue()

取出任务。

peek()

查看当前任务，但不删除。

remove(Task)

删除任务。

clear()

清空任务队列。

count()

获得任务数量。

2.5 Task Queue 不负责决策

Task Queue 的职责是：

保存任务
排序任务
提供任务
删除任务
管理等待状态

它不负责：

认知
推理
决策
风险判断
知识学习

例如：

Decision
 ↓
Create Task
 ↓
Task Queue

而不是：

Task Queue
 ↓
自己决定应该做什么

3. Task State

Task State 表示任务当前处于什么阶段。

建议定义：

NEW
READY
QUEUED
WAITING
RUNNING
PAUSED
COMPLETED
FAILED
CANCELLED
TIMEOUT
CONFLICT
UNKNOWN

3.1 NEW

任务刚刚创建：

Task → NEW

此时任务还没有进入执行队列。

3.2 READY

任务已经完成基本检查，可以执行：

NEW
 ↓
Validation
 ↓
READY

例如：

目标存在
条件完整
Action 存在
所需能力存在
依赖正常

3.3 QUEUED

任务已经进入任务队列：

READY
 ↓
QUEUED

表示：

任务已经准备好，但正在等待 Executor。

3.4 WAITING

任务因为条件或依赖暂时不能执行：

WAITING

例如：

等待设备连接
等待传感器数据
等待其他任务完成
等待外部反馈

3.5 RUNNING

Executor 已经开始执行：

QUEUED
 ↓
RUNNING

3.6 COMPLETED

任务成功完成：

RUNNING
 ↓
COMPLETED

但需要注意：

Task COMPLETED 表示任务执行流程完成，不等于外部世界一定达到预期结果。

最终结果仍然需要通过 Task Result 和 Verification 判断。

3.7 FAILED

任务执行失败：

RUNNING
 ↓
FAILED

失败原因应该进入 Result：

error
message
failed_action
state

3.8 CANCELLED

任务被取消：

QUEUED
 ↓
CANCELLED

或者：

RUNNING
 ↓
CANCELLED

例如出现更高优先级任务、风险变化或者外部取消请求。

3.9 TIMEOUT

任务超过允许执行时间：

RUNNING
 ↓
TIMEOUT

之后可以进入：

Detection
 ↓
Risk
 ↓
Diagnosis
 ↓
Decision

3.10 CONFLICT

任务与其他任务、规则、状态或资源发生冲突：

Task_A → RUN
Task_B → STOP

如果无法通过 Priority 或 Conflict Resolution 解决：

Task → CONFLICT

4. Task Priority

Task Priority 表示任务的重要程度和执行顺序。

例如：

CRITICAL = 100
HIGH     = 80
MEDIUM   = 50
LOW      = 20

或者直接使用：

priority = 0 ~ 100

4.1 Priority 来源

任务优先级可以来自：

Goal
Risk
Time
State
Importance
Dependency
System Rule
Experience

例如：

Task_A
风险：LOW
紧急性：LOW
priority = 30

而：

Task_B
风险：HIGH
紧急性：HIGH
priority = 90

那么：

Task_B > Task_A

4.2 Task Priority 不等于 Decision Priority

前面 Priority 系统负责候选方案的排序。

Task Priority 是：

已经形成任务以后，多个任务之间如何排序。

例如：

Decision
 ↓
Candidates
 ↓
Priority
 ↓
Selected Action
 ↓
Task
 ↓
Task Priority
 ↓
Task Queue

因此存在两个不同层次：

Decision Priority
    ↓
选择哪个方案

Task Priority
    ↓
多个任务先执行哪个

5. Task Executor

5.1 Task Executor 定义

Task Executor（任务执行器）负责从 Task Queue 中获取任务，并按照任务结构执行。

核心流程：

Task Queue
    ↓
Task Executor
    ↓
Validate
    ↓
Prepare
    ↓
Behavior
    ↓
Action
    ↓
Result

5.2 Executor 的主要职责

getTask()
validateTask()
prepareTask()
executeTask()
handleResult()
handleError()
completeTask()
cancelTask()

5.3 Task Executor 不负责重新决策

这是非常重要的边界。

Executor 不应该变成：

Executor
 ↓
重新认知
 ↓
重新推理
 ↓
重新决定

而应该：

Decision
 ↓
Task
 ↓
Task Queue
 ↓
Task Executor
 ↓
Behavior
 ↓
Action

如果执行过程中出现新的重要信息：

Action
 ↓
Feedback
 ↓
Information
 ↓
Perception
 ↓
Cognition
 ↓
Reasoning
 ↓
Decision

系统可以产生新的 Task。

也就是说：

Executor 执行任务，不替代 Individual 的认知与决策系统。

5.4 Task Executor 示例

class TaskExecutor
{
    public function execute($task)
    {
        if ($task['state'] !== 'READY') {
            return array(
                'state' => 'FAILED',
                'error' => 'Task is not ready'
            );
        }

        $task['state'] = 'RUNNING';

        // 调用 Behavior / Action 执行任务
        $result = $this->runActions($task['actions']);

        if ($result['state'] === 'SUCCESS') {
            $task['state'] = 'COMPLETED';
        } else {
            $task['state'] = 'FAILED';
        }

        return array(
            'task' => $task,
            'result' => $result
        );
    }

    protected function runActions($actions)
    {
        return array(
            'state' => 'SUCCESS',
            'actions' => $actions
        );
    }
}

这里的重点不是代码复杂度，而是职责边界：

TaskExecutor = 执行任务

而不是：

TaskExecutor = Individual 的全部智能

6. Task Result

Task Result 是任务执行后的结构化结果。

基本结构：

TaskResult
├── id
├── task_id
├── state
├── output
├── changes
├── actions
├── feedback
├── error
├── message
├── started_at
└── completed_at

例如：

{
    "id": "TaskResult_001",
    "task_id": "Task_A",
    "state": "SUCCESS",
    "output": {
        "speed": 20
    },
    "changes": {
        "Vehicle_A.speed": {
            "before": 40,
            "after": 20
        }
    },
    "feedback": {
        "device_state": "RUNNING"
    },
    "error": null
}

6.1 Task Result 与 Action Result

一个 Task 可以包含多个 Action。

例如：

Task：车辆减速
    ↓
Behavior：减速行为
    ↓
Action 1：读取当前速度
    ↓
ActionResult 1
    ↓
Action 2：设置速度 20
    ↓
ActionResult 2
    ↓
Action 3：验证速度
    ↓
ActionResult 3
    ↓
TaskResult

因此：

ActionResult
=
单个 Action 的结果

而：

TaskResult
=
整个 Task 的结果

6.2 Task Result 与 Verification

例如：

Task:
SET_SPEED = 20

Executor 返回：

TaskResult = SUCCESS

但实际车辆反馈：

speed = 25

那么：

Task Execution = SUCCESS
Verification = FAILED

因此：

TaskResult.SUCCESS ≠ 目标已经实现。

这与前面 Repair 和 Verification 的关系完全一致。

7. Individual Task

Individual Task 是 SAI Individual 对任务系统的完整组织。

Individual 不应该只有：

receive()
process()

而应该逐渐形成：

Individual
│
├── InformationReceiver
├── SceneCollector
├── Perception
├── Cognition
├── Memory
├── Reasoning
├── Decision
│
├── TaskManager
│   ├── Task
│   ├── Task Queue
│   ├── Task Priority
│   └── Task State
│
├── TaskExecutor
│   ├── Behavior
│   └── Action
│
├── Expression
├── Renderer
├── Adapter
│
├── Feedback
├── Experience
├── Learning
└── Update

7.1 Individual 创建任务

例如：

Vehicle_A
speed = 40
Obstacle_A
distance = 20
relative_speed = 30

Individual 感知并理解场景：

Perception
 ↓
Cognition
 ↓
Reasoning
 ↓
Conclusion

得到：

Vehicle_A.risk = HIGH

然后：

Decision
 ↓
DECELERATE

形成 Task：

Task_A
{
    target: Vehicle_A,
    goal: DECELERATE,
    priority: HIGH,
    state: READY
}

7.2 Individual 将 Task 放入 Queue

Decision
 ↓
Create Task
 ↓
Validate
 ↓
Task Queue

如果同时存在：

Task_A  检查设备
priority=40

Task_B  避免碰撞
priority=100

Task_C  保存经验
priority=20

Queue 排序：

Task_B  100
   ↓
Task_A   40
   ↓
Task_C   20

7.3 Individual 执行 Task

Task Queue
     ↓
Task Executor
     ↓
Task_B
     ↓
Behavior
     ↓
Action
     ↓
Adapter
     ↓
Vehicle_A

车辆实际发生变化：

speed 40
  ↓
speed 30
  ↓
speed 20

7.4 Individual 获取结果

外部设备返回：

Feedback
{
    "device": "Vehicle_A",
    "state": "RUNNING",
    "speed": 20,
    "result": "SUCCESS"
}

Individual 接收：

External World
 ↓
Adapter
 ↓
Feedback
 ↓
Information
 ↓
Perception

然后更新：

TaskResult
 ↓
Task = COMPLETED

7.5 Task 完成后的后续处理

Task 完成并不意味着整个 Individual 停止。

而是：

TaskResult
    ↓
Feedback
    ↓
Experience
    ↓
Learning
    ↓
Memory Update
    ↓
等待新的 Information

最终再次进入：

Information
 ↓
Perception
 ↓
Cognition
 ↓
Reasoning
 ↓
Decision
 ↓
Task

于是任务系统被纳入完整闭环。

8. Task System 完整运行模型

将本章与前面的章节连接起来，可以形成：

Information
    ↓
Perception
    ↓
Cognition
    ↓
Reasoning
    ↓
Decision
    ↓
Task Creation
    ↓
Task Validation
    ↓
Task Priority
    ↓
Task Queue
    ↓
Task Executor
    ↓
Behavior
    ↓
Action
    ↓
Expression
    ↓
Renderer
    ↓
Adapter
    ↓
External World
    ↓
Feedback
    ↓
Task Result
    ↓
Verification
    ↓
Experience
    ↓
Learning
    ↓
Memory Update
    ↓
New Information

9. Task System 与 State Machine

第96章的 State Machine 与第97章的 Task System 是两个不同机制。

State Machine

解决：

状态如何变化？

Event
 ↓
Condition
 ↓
Transition
 ↓
Action
 ↓
New State

Task System

解决：

有哪些工作需要执行？按照什么顺序执行？

Task
 ↓
Priority
 ↓
Queue
 ↓
Executor
 ↓
Result

两者可以结合：

Task Executor
      ↓
检查 State Machine
      ↓
允许执行？
   ↙      ↘
 YES       NO
 ↓          ↓
Action    WAITING

例如：

Task = START_MACHINE

但是 Machine 当前：

ERROR

State Machine 不允许：

ERROR → RUNNING

那么 Task 不能直接执行：

Task → WAITING / FAILED

需要先：

Diagnosis
 ↓
Repair
 ↓
Verification
 ↓
State Machine
 ↓
READY
 ↓
Task Executor

这就把任务系统与自我维护系统连接起来。

10. Task System 核心关系

整个任务系统可以压缩成：

Task
 ↓
Task State
 ↓
Task Priority
 ↓
Task Queue
 ↓
Task Executor
 ↓
Behavior
 ↓
Action
 ↓
Task Result

其中：

对象	作用
Task	定义要完成的工作
Task Queue	保存等待执行的任务
Task State	描述任务当前状态
Task Priority	确定任务执行顺序
Task Executor	执行任务
Behavior	组织执行过程
Action	执行具体操作
Task Result	记录整个任务结果

本章核心模型

Individual
     ↓
Decision
     ↓
Task
     ↓
Priority
     ↓
Task Queue
     ↓
Task Executor
     ↓
Behavior
     ↓
Action
     ↓
External Execution
     ↓
Task Result
     ↓
Feedback

本章核心定义

Task 是 SAI Individual 对需要完成的目标或工作进行结构化描述的执行对象。

Task Queue 负责组织等待执行的任务。

Task Priority 负责确定多个任务之间的执行顺序。

Task Executor 负责按照任务定义组织并执行任务。

Task Result 负责记录整个任务的执行结果。

因此，第97章完成了一个重要结构：

第89章 Decision
        ↓
第97章 Task
        ↓
第90章 Behavior
        ↓
第90章 Action
        ↓
第91章 Feedback

也就是说，Decision 解决“决定做什么”，Task 解决“把这件事组织成可执行工作”，Behavior/Action 解决“具体怎么执行”。

第97章 任务系统

第97章 任务系统

1. Task

1.1 Task 定义

1.2 Task 基本结构

1.3 Task 与 Action 的区别

2. Task Queue

2.1 Task Queue 定义

2.2 FIFO Queue

2.3 Priority Queue

2.4 Task Queue 的基本操作

2.5 Task Queue 不负责决策

3. Task State

3.1 NEW

3.2 READY

3.3 QUEUED

3.4 WAITING

3.5 RUNNING

3.6 COMPLETED

3.7 FAILED

3.8 CANCELLED

3.9 TIMEOUT

3.10 CONFLICT

4. Task Priority

4.1 Priority 来源

4.2 Task Priority 不等于 Decision Priority

5. Task Executor

5.1 Task Executor 定义

5.2 Executor 的主要职责

5.3 Task Executor 不负责重新决策

5.4 Task Executor 示例

6. Task Result

6.1 Task Result 与 Action Result

6.2 Task Result 与 Verification

7. Individual Task

7.1 Individual 创建任务

7.2 Individual 将 Task 放入 Queue

7.3 Individual 执行 Task

7.4 Individual 获取结果

7.5 Task 完成后的后续处理

8. Task System 完整运行模型

9. Task System 与 State Machine

State Machine

Task System

10. Task System 核心关系

本章核心模型

本章核心定义