第222章　BehaviorActionRepository

222.1 BehaviorActionRepository定义

第221章已经建立：

$Goal→Capability→Matching→Method→Decision→BehaviorGoal \rightarrow Capability \rightarrow Matching \rightarrow Method \rightarrow Decision \rightarrow Behavior$

DecisionEngine完成方案选择以后，系统不能停留在“选择结果”。

选定的 Method 必须转换成当前可以执行的 Behavior，Behavior进一步组织 Action，Action进入 Execution，Execution产生 Result。

因此形成：

Decision
 ↓
Method
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result

这一阶段产生大量必须长期保存的数据：

Behavior
Action
Result
Execution History

因此建立：

$BehaviorActionRepositoryBehaviorActionRepository$

核心模型：

$BAR=(B,A,R,E,H,Q,P,T)BAR=(B,A,R,E,H,Q,P,T)$

其中：

$BB$ ：Behavior；
$AA$ ：Action；
$RR$ ：Result；
$EE$ ：Execution；
$HH$ ：Execution History；
$QQ$ ：Query；
$PP$ ：Persistence；
$TT$ ：Time。

因此：

$BehaviorActionRepository=Behavior+Action+Result+ExecutionHistory\boxed{ BehaviorActionRepository = Behavior + Action + Result + ExecutionHistory }$

这里需要特别区分：

$BehaviorActionRepository≠BehaviorEngineBehaviorActionRepository \neq BehaviorEngine$ $BehaviorActionRepository≠ActionEngineBehaviorActionRepository \neq ActionEngine$ $BehaviorActionRepository≠ExecutionEngineBehaviorActionRepository \neq ExecutionEngine$

Repository负责保存、读取、更新和查询执行事实。

Engine负责计算和运行。

222.2 Behavior领域对象

前面的 BehaviorEngine 已经定义：

$B=(G,C,A,E,R,S)B=(G,C,A,E,R,S)$

其中：

$GG$ ：Goal；
$CC$ ：Condition；
$AA$ ：Action Sequence；
$EE$ ：Execution；
$RR$ ：Result；
$SS$ ：State。

Behavior回答：

$当前准备如何完成一个目标\boxed{当前准备如何完成一个目标}$

它是从 Method 和 Decision 形成的当前可执行行为结构。

例如：

Goal G1
 ↓
Decision D1
 ↓
Method M1
 ↓
Behavior B1
 ↓
A1 → A2 → A3

Behavior不是单个 Action。

$Behavior≠ActionBehavior\neq Action$

Behavior是由多个 Action 组成的完整行为。

222.3 Action领域对象

Action模型：

$A=(T,O,C,P,R,S)A=(T,O,C,P,R,S)$

其中：

$TT$ ：Action Type；
$OO$ ：Target Object；
$CC$ ：Condition；
$PP$ ：Parameters；
$RR$ ：Expected Result；
$SS$ ：Action State。

Action表示具体操作。

例如：

Behavior B1
 ↓
Action A1：读取对象
 ↓
Action A2：修改属性
 ↓
Action A3：保存状态

因此：

$Behavior={A1,A2,…,An}Behavior=\{A_1,A_2,\ldots,A_n\}$

Action是 Behavior 的具体操作单元。

222.4 Result领域对象

Result表示实际执行产生的结果。

定义：

$R=(Ex,Ar,S,C,T)R=(E_x,A_r,S,C,T)$

其中：

$ExE_x$ ：Execution；
$ArA_r$ ：Actual Result；
$SS$ ：Result State；
$CC$ ：Comparison；
$TT$ ：Result Time。

这里使用 $ExE_x$ 表示 Execution，避免与 Environment 或其他变量混淆。

Result回答：

$实际发生了什么\boxed{实际发生了什么}$

例如：

Expected:
success

Actual:
failed

State:
blocked

因此：

$ExpectedResult≠ActualResultExpectedResult\neq ActualResult$

Repository必须保存实际 Result，而不能用预期结果代替实际结果。

222.5 Execution History

Execution History记录实际发生过的执行过程。

定义：

$EH=(Ex,B,A,Sb,Sa,R,T)EH=(E_x,B,A,S_b,S_a,R,T)$

其中：

$ExE_x$ ：Execution；
$BB$ ：Behavior；
$AA$ ：Action；
$SbS_b$ ：执行前状态；
$SaS_a$ ：执行后状态；
$RR$ ：实际 Result；
$TT$ ：执行时间。

Execution History回答：

什么时候执行？
执行了什么？
执行前是什么状态？
执行后是什么状态？
产生了什么结果？

因此：

$ExecutionHistory≠ResultExecutionHistory\neq Result$

Result描述结果。

Execution History描述完整执行事实及其时间关系。

222.6 Behavior与Action的关系

Behavior是上层执行结构：

$B→{A1,A2,…,An}B\rightarrow\{A_1,A_2,\ldots,A_n\}$

例如：

Behavior B1
 ├── Action A1
 ├── Action A2
 └── Action A3

BehaviorRepository负责保存 Behavior。

ActionRepository负责保存 Action。

如果采用协作式 Repository：

BehaviorActionRepository
 ├── Behavior
 ├── Action
 ├── Result
 └── Execution History

但 Domain Object 仍然保持独立。

$Behavior≠ActionBehavior\neq Action$

222.7 Behavior与Method的关系

第221章中的 Method：

$M=(T,C,P,A,R)M=(T,C,P,A,R)$

表示可执行方案。

Behavior则是当前一次实际执行所形成的行为实例。

因此：

$Method→BehaviorMethod\rightarrow Behavior$

但：

$Method≠BehaviorMethod\neq Behavior$

例如同一个 Method：

Method M1

在不同时间可以形成：

Behavior B1
Behavior B2
Behavior B3

因为：

State
Condition
Object
Resource
Time

可能不同。

所以：

$M1→B1,B2,B3M_1\rightarrow B_1,B_2,B_3$

是合法的。

222.8 Behavior保存

Behavior保存流程：

Behavior
 ↓
Validate
 ↓
Map
 ↓
Persist
 ↓
ReadBack
 ↓
Verify

公式：

$Save(B)→Validate→Persist→VerifySave(B) \rightarrow Validate \rightarrow Persist \rightarrow Verify$

Behavior至少需要能够追踪：

Behavior ID
Goal ID
Method ID
Decision ID
Individual ID
State
Created Time

这样可以建立：

$Goal→Decision→Method→BehaviorGoal \rightarrow Decision \rightarrow Method \rightarrow Behavior$

完整追踪链。

222.9 Action保存

Action通常属于某个 Behavior。

因此：

$Behavior→ActionBehavior \rightarrow Action$

保存：

Action
 ↓
Validate
 ↓
Bind Behavior
 ↓
Persist
 ↓
Verify

Action必须记录：

Action ID
Behavior ID
Action Type
Target Object
Condition
Parameters
Expected Result
State
Sequence

其中 Sequence 很重要。

例如：

A1 → A2 → A3

不能被错误保存为：

A3 → A1 → A2

因此 Action 顺序也是 Behavior 结构的一部分。

222.10 Action Sequence

定义：

$AS={A1,A2,…,An}AS=\{A_1,A_2,\ldots,A_n\}$

如果存在明确依赖：

$Ai→AjA_i\rightarrow A_j$

则：

$AiA_i$

必须先于：

$AjA_j$

执行。

因此 Repository 保存的不仅是 Action，还要保存 Action 与 Behavior 的关联关系。

例如：

behavior_actions

behavior_id
action_id
sequence_no
state
created_at

这样可以恢复：

Behavior B1
 ↓
A1
 ↓
A2
 ↓
A3

222.11 Execution与Action

Action是操作定义。

Execution是实际执行过程。

因此：

$Action≠ExecutionAction\neq Execution$

例如：

Action A1

表示：

Process Object A

实际执行：

Execution E1

可能：

started
completed
failed
cancelled

因此：

$A1→E1A_1\rightarrow E_1$

同一个 Action 也可能被执行多次：

$A1→E1,E2,E3A_1\rightarrow E_1,E_2,E_3$

所以不能把 Action 和 Execution 设计成同一个对象。

222.12 Execution状态

Execution可以采用：

Created
 ↓
Ready
 ↓
Running
 ↓
Completed

异常分支：

Running
 ├── Failed
 ├── Cancelled
 └── Interrupted

因此：

$ExecutionStateExecutionState$

应该独立保存。

ExecutionRepository负责保存实际执行状态。

StateEngine负责计算合法状态转换。

222.13 Result保存

执行完成以后：

$Execution→ResultExecution\rightarrow Result$

Result必须来自实际 Execution。

保存过程：

Execution
 ↓
Actual Result
 ↓
Compare Expected / Actual
 ↓
Result
 ↓
Persist
 ↓
Verify

比较：

$C=Compare(Re,R)C=Compare(R_e,R)$

其中：

$ReR_e$ ：Expected Result；
$RR$ ：Actual Result；
$CC$ ：Comparison。

可能结果：

Equal
Partial
Different
Failed
Unknown

不能因为 Execution 状态为 completed 就直接认为：

$Result=SuccessResult=Success$

因为：

$ExecutionCompleted≠GoalCompletedExecutionCompleted \neq GoalCompleted$

甚至：

$ExecutionCompleted≠ResultVerifiedExecutionCompleted \neq ResultVerified$

222.14 Execution History保存

每次真实执行都应该形成历史记录。

例如：

E1
 ↓
Failed

E2
 ↓
Completed

应该保存：

Execution History 1
Execution History 2

而不是只保存：

last_execution = E2

历史模型：

$EH={eh1,eh2,…,ehn}EH=\{eh_1,eh_2,\ldots,eh_n\}$

这为：

Memory
Experience
Risk
Diagnosis
Learning

提供真实数据来源。

222.15 Execution History与State History

二者必须区分。

Execution History：

$EH=(Ex,B,A,Sb,Sa,R,T)EH=(E_x,B,A,S_b,S_a,R,T)$

State History：

$SH=(O,Sb,Sa,E,R,T)SH=(O,S_b,S_a,E,R,T)$

Execution History关注：

$执行过程\boxed{执行过程}$

State History关注：

$状态变化\boxed{状态变化}$

一次 Execution 可以导致多个 State Change。

因此：

$ExecutionHistory≠StateHistoryExecutionHistory\neq StateHistory$

222.16 Execution History与Feedback

Execution完成：

Execution
 ↓
Result
 ↓
Feedback

History则记录事实：

Execution
 ↓
Execution History

因此：

$ExecutionHistoryExecutionHistory$

可以成为 Feedback 的事实来源，但：

$ExecutionHistory≠FeedbackExecutionHistory\neq Feedback$

Feedback 是对实际结果、状态变化、环境变化等进行结构化处理后的信息。

222.17 Result与Feedback

必须继续保持前面建立的边界：

$Result≠FeedbackResult\neq Feedback$

Result：

$实际结果\boxed{实际结果}$

Feedback：

$对实际结果及状态变化的结构化反馈\boxed{对实际结果及状态变化的结构化反馈}$

完整关系：

Execution
 ↓
Result
 ↓
Feedback
 ↓
State Update

而 Repository 分别保存：

ResultRepository
FeedbackRepository
StateRepository

或者由更高层协作 Repository 进行查询协调。

222.18 BehaviorActionRepository查询

Repository应该支持多种查询。

Behavior：

findBehaviorById()
findBehaviorsByGoalId()
findBehaviorsByMethodId()
findBehaviorsByDecisionId()
findBehaviorsByIndividualId()

Action：

findActionById()
findActionsByBehaviorId()
findActionsByType()

Result：

findResultByExecutionId()
findResultsByBehaviorId()
findFailedResults()
findSuccessfulResults()

Execution History：

findExecutionHistoryByBehaviorId()
findExecutionHistoryByActionId()
findExecutionHistoryByIndividualId()
findExecutionHistoryByTimeRange()

注意：

$Query≠CalculationQuery\neq Calculation$

Repository查询结果以后，还需要由相应 Engine 进行认知计算。

222.19 Behavior查询不等于Behavior计算

例如：

$findBehaviorById(B1)→B1findBehaviorById(B1)\rightarrow B1$

只是读取。

如果需要判断：

Behavior是否可执行？

则应该：

$BehaviorEngineBehaviorEngine$

计算：

$BehaviorReady=Gv∧Sv∧Mv∧Cv∧Rv∧EvBehaviorReady = G_v \land S_v \land M_v \land C_v \land R_v \land E_v$

因此：

$Repository=ReadRepository=Read$ $Engine=CalculateEngine=Calculate$

222.20 Action查询不等于Action执行

Repository可以：

$findAction(A1)→A1findAction(A1)\rightarrow A1$

但不能：

$Repository→Execute(A1)Repository\rightarrow Execute(A1)$

正确结构：

BehaviorRepository
 ↓
Behavior
 ↓
BehaviorEngine
 ↓
ActionEngine
 ↓
ExecutionEngine
 ↓
Result

Repository不能越过 Engine 直接承担执行职责。

222.21 PHP接口

可以建立：

<?php

interface BehaviorActionRepositoryInterface
{
    public function findBehaviorById($id);

    public function findBehaviorsByGoalId($goalId);

    public function findBehaviorsByMethodId($methodId);

    public function findBehaviorsByDecisionId($decisionId);

    public function findBehaviorByIndividualId($individualId);

    public function saveBehavior($behavior);

    public function updateBehavior($behavior);

    public function findActionById($id);

    public function findActionsByBehaviorId($behaviorId);

    public function saveAction($action);

    public function updateAction($action);

    public function findResultByExecutionId($executionId);

    public function findResultsByBehaviorId($behaviorId);

    public function saveResult($result);

    public function updateResult($result);

    public function saveExecutionHistory($history);

    public function findExecutionHistoryByBehaviorId($behaviorId);

    public function findExecutionHistoryByActionId($actionId);

    public function findExecutionHistoryByIndividualId($individualId);
}

这是 Repository 层接口定义。

222.22 BehaviorMapper

class BehaviorMapper
{
    public function toPersistence($behavior)
    {
        return array(
            'id' => $behavior->getId(),
            'individual_id' =>
                $behavior->getIndividualId(),
            'goal_id' =>
                $behavior->getGoalId(),
            'method_id' =>
                $behavior->getMethodId(),
            'decision_id' =>
                $behavior->getDecisionId(),
            'state' =>
                $behavior->getState(),
            'created_at' =>
                $behavior->getCreatedAt()
        );
    }

    public function toDomain($data)
    {
        $behavior = new Behavior();

        $behavior->setId($data['id']);
        $behavior->setIndividualId(
            $data['individual_id']
        );
        $behavior->setGoalId(
            $data['goal_id']
        );
        $behavior->setMethodId(
            $data['method_id']
        );
        $behavior->setDecisionId(
            $data['decision_id']
        );
        $behavior->setState(
            $data['state']
        );

        return $behavior;
    }
}

Mapper只负责：

$PersistenceData↔DomainObjectPersistenceData \leftrightarrow DomainObject$

不负责 Behavior 计算。

222.23 ActionMapper

class ActionMapper
{
    public function toPersistence($action)
    {
        return array(
            'id' => $action->getId(),
            'behavior_id' =>
                $action->getBehaviorId(),
            'action_type' =>
                $action->getType(),
            'target_object_id' =>
                $action->getTargetObjectId(),
            'condition_data' =>
                $action->getCondition(),
            'parameter_data' =>
                $action->getParameters(),
            'expected_result' =>
                $action->getExpectedResult(),
            'state' =>
                $action->getState()
        );
    }

    public function toDomain($data)
    {
        $action = new Action();

        $action->setId($data['id']);
        $action->setBehaviorId(
            $data['behavior_id']
        );
        $action->setType(
            $data['action_type']
        );
        $action->setTargetObjectId(
            $data['target_object_id']
        );
        $action->setCondition(
            $data['condition_data']
        );
        $action->setParameters(
            $data['parameter_data']
        );
        $action->setExpectedResult(
            $data['expected_result']
        );
        $action->setState(
            $data['state']
        );

        return $action;
    }
}

222.24 ResultMapper

class ResultMapper
{
    public function toPersistence($result)
    {
        return array(
            'id' => $result->getId(),
            'execution_id' =>
                $result->getExecutionId(),
            'actual_result' =>
                $result->getActualResult(),
            'comparison' =>
                $result->getComparison(),
            'state' =>
                $result->getState(),
            'result_time' =>
                $result->getTime()
        );
    }

    public function toDomain($data)
    {
        $result = new Result();

        $result->setId($data['id']);
        $result->setExecutionId(
            $data['execution_id']
        );
        $result->setActualResult(
            $data['actual_result']
        );
        $result->setComparison(
            $data['comparison']
        );
        $result->setState(
            $data['state']
        );
        $result->setTime(
            $data['result_time']
        );

        return $result;
    }
}

222.25 Execution History Mapper

class ExecutionHistoryMapper
{
    public function toPersistence($history)
    {
        return array(
            'execution_id' =>
                $history->getExecutionId(),
            'behavior_id' =>
                $history->getBehaviorId(),
            'action_id' =>
                $history->getActionId(),
            'before_state' =>
                $history->getBeforeState(),
            'after_state' =>
                $history->getAfterState(),
            'result_data' =>
                $history->getResult(),
            'created_at' =>
                $history->getTime()
        );
    }
}

History Mapper 的目标是保持实际执行事实可恢复、可追踪。

222.26 MySQL数据结构

Behavior：

CREATE TABLE behaviors (
    id INT NOT NULL AUTO_INCREMENT,
    individual_id INT NOT NULL,
    goal_id INT NOT NULL,
    method_id INT NOT NULL,
    decision_id INT NOT NULL,
    state VARCHAR(50) NOT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME,
    PRIMARY KEY (id)
);

Action：

CREATE TABLE actions (
    id INT NOT NULL AUTO_INCREMENT,
    behavior_id INT NOT NULL,
    action_type VARCHAR(100) NOT NULL,
    target_object_id INT,
    condition_data TEXT,
    parameter_data TEXT,
    expected_result TEXT,
    state VARCHAR(50) NOT NULL,
    PRIMARY KEY (id)
);

Behavior与Action关联：

CREATE TABLE behavior_actions (
    id INT NOT NULL AUTO_INCREMENT,
    behavior_id INT NOT NULL,
    action_id INT NOT NULL,
    sequence_no INT NOT NULL,
    state VARCHAR(50),
    PRIMARY KEY (id)
);

Result：

CREATE TABLE results (
    id INT NOT NULL AUTO_INCREMENT,
    execution_id INT NOT NULL,
    actual_result TEXT,
    comparison VARCHAR(50),
    state VARCHAR(50),
    result_time DATETIME NOT NULL,
    PRIMARY KEY (id)
);

Execution History：

CREATE TABLE execution_history (
    id INT NOT NULL AUTO_INCREMENT,
    execution_id INT NOT NULL,
    behavior_id INT NOT NULL,
    action_id INT,
    before_state VARCHAR(50),
    after_state VARCHAR(50),
    result_data TEXT,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id)
);

上述 SQL 是 Repository 结构设计示例，正式工程中应根据实际数据库版本、已有表结构和外键策略进行验证后实施。

222.27 一个Behavior对应多个Action

例如：

Behavior B1

包含：

A1
A2
A3

数据库关系：

$1:N1:N$

即：

$Behavior→Action1Behavior \rightarrow Action_1$ $Behavior→Action2Behavior \rightarrow Action_2$ $Behavior→Action3Behavior \rightarrow Action_3$

因此不能把所有 Action 简单压缩成一个无法独立查询的字段。

如果 Action 需要独立生命周期、执行记录和历史，则应作为独立 Domain Object 持久化。

222.28 一个Action可以产生多个Execution

实际系统中：

Action A1

可能第一次失败：

Execution E1 = Failed

经过 Diagnosis / Repair 后再次执行：

Execution E2 = Completed

因此：

$Action→{E1,E2,…,En}Action\rightarrow\{E_1,E_2,\ldots,E_n\}$

这也是为什么：

$Action≠ExecutionAction\neq Execution$

必须保持独立。

222.29 一个Execution产生Result

通常：

$Execution→ResultExecution \rightarrow Result$

例如：

Execution E1
 ↓
Actual Result = Failed

然后：

Result R1

进入：

FeedbackEngine
DiagnosisEngine
RiskEngine
MemoryEngine
LearningEngine

形成：

Execution
 ↓
Result
 ↓
Feedback
 ↓
Diagnosis / Memory / Learning

222.30 执行失败的完整历史

例如：

Behavior B1
 ↓
Action A2
 ↓
Execution E1
 ↓
Result R1 = Failed
 ↓
Execution History EH1

然后：

Feedback
 ↓
Diagnosis
 ↓
Repair
 ↓
Action A2
 ↓
Execution E2
 ↓
Result R2 = Success
 ↓
Execution History EH2

因此：

$EH1≠EH2EH_1\neq EH_2$

两个执行事实都必须保存。

222.31 Repository与Memory

Execution History 是 MemoryEngine 的重要事实来源。

Execution History
 ↓
History
 ↓
MemoryEngine
 ↓
Memory

但：

$ExecutionHistory≠MemoryExecutionHistory\neq Memory$

History记录：

$发生过什么\boxed{发生过什么}$

Memory记录：

$哪些过去信息值得保留和调用\boxed{哪些过去信息值得保留和调用}$

因此 Repository 不负责决定哪些历史应该进入 Memory。

222.32 Repository与Experience

ExperienceEngine可以使用：

Execution History
Result
Feedback
Behavior History

形成：

$ExperienceExperience$

完整关系：

Execution History
 ↓
Comparison
 ↓
Relation
 ↓
Pattern
 ↓
Experience

所以：

$ExecutionHistory→ExperienceExecutionHistory\rightarrow Experience$

但不能直接：

$Repository→ExperienceRepository\rightarrow Experience$

Experience 的形成仍然属于 ExperienceEngine。

222.33 Repository与Learning

LearningEngine可以从执行历史获得学习事实：

Execution History
 ↓
Result
 ↓
Feedback
 ↓
Experience
 ↓
LearningEngine
 ↓
Update Candidate
 ↓
UpdateEngine

Repository只提供真实持久化数据。

因此：

$Repository≠LearningEngineRepository\neq LearningEngine$

222.34 Behavior状态更新

Behavior状态可能由 Action / Execution / Result 产生。

例如：

Behavior B1
 ↓
A1 Completed
 ↓
A2 Failed
 ↓
Behavior Failed

或者：

A1 Completed
 ↓
A2 Completed
 ↓
A3 Completed
 ↓
Behavior Completed

因此：

$SB=f(SA,SEx,C)S_B=f(S_A,S_{E_x},C)$

其中：

$SBS_B$ ：Behavior State；
$SAS_A$ ：Action States；
$SExS_{E_x}$ ：Execution States；
$CC$ ：Behavior Condition。

BehaviorEngine计算状态。

StateEngine负责合法状态转换。

BehaviorActionRepository负责保存结果。

222.35 Result验证

Result不能仅因为存在就认为有效。

定义：

$ValidResult=Execution∧Actual∧Comparison∧EvidenceValidResult = Execution \land Actual \land Comparison \land Evidence$

其中：

Execution：存在真实 Execution；
Actual：存在实际结果；
Comparison：存在预期与实际比较；
Evidence：存在可验证证据。

因此：

$Exists(Result)≠Valid(Result)Exists(Result) \neq Valid(Result)$

进一步：

$Valid(Result)≠Verified(Result)Valid(Result) \neq Verified(Result)$

222.36 BehaviorActionRepository与事务

一个完整执行过程可能同时产生：

Behavior
Action
Execution
Result
Execution History

可以由 Service / TransactionManager 协调：

Begin
 ↓
Create Behavior
 ↓
Create Action
 ↓
Create Execution
 ↓
Actual Execution
 ↓
Create Result
 ↓
Create Execution History
 ↓
Verify
 ↓
Commit

但是：

$DatabaseRollback≠ExternalExecutionRollbackDatabaseRollback \neq ExternalExecutionRollback$

如果 Execution 已经对外部对象产生实际影响，数据库回滚并不能让外部世界自动恢复。

因此实际系统必须区分：

Persistence Transaction

与：

Execution Compensation / Repair

222.37 BehaviorActionRepository的完整PHP结构

推荐结构：

app/
├── Domain/
│   ├── Behavior/
│   │   └── Behavior.php
│   ├── Action/
│   │   └── Action.php
│   ├── Result/
│   │   └── Result.php
│   └── Execution/
│       └── ExecutionHistory.php
│
├── Engines/
│   ├── BehaviorEngine.php
│   ├── ActionEngine.php
│   └── ExecutionEngine.php
│
├── Services/
│   ├── BehaviorService.php
│   └── ExecutionService.php
│
├── Repositories/
│   ├── BehaviorRepository.php
│   ├── ActionRepository.php
│   ├── ResultRepository.php
│   ├── ExecutionHistoryRepository.php
│   └── BehaviorActionRepository.php
│
└── Infrastructure/
    ├── Database/
    └── Mapping/

这种结构能够继续保持：

$Domain≠Engine≠Service≠RepositoryDomain \neq Engine \neq Service \neq Repository$

222.38 完整执行持久化链

最终形成：

Goal
 ↓
Capability
 ↓
Matching
 ↓
Method
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Execution History

Repository对应：

Goal
 ↓
GoalRepository

Capability
 ↓
CapabilityRepository

Method
 ↓
MethodRepository

Decision
 ↓
DecisionRepository

Behavior
 ↓
BehaviorRepository

Action
 ↓
ActionRepository

Result
 ↓
ResultRepository

Execution History
 ↓
ExecutionHistoryRepository

协作层则可以提供：

$BehaviorActionRepositoryBehaviorActionRepository$

对上述执行阶段数据进行联合查询。

222.39 从执行结果进入认知闭环

执行数据保存以后，继续进入 ICAI 的认知闭环：

Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
Memory
 ↓
Experience
 ↓
Learning
 ↓
Update
 ↓
New Cognitive State

其中：

BehaviorActionRepository

负责保存：

$Behavior+Action+Result+ExecutionHistoryBehavior+Action+Result+ExecutionHistory$

而不是负责整个学习闭环。

222.40 与前一章MethodDecisionRepository连接

第221章：

Method
 ↓
Decision
 ↓
Selected Method

第222章：

Selected Method
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Execution History

于是：

$Method→Decision→Behavior→Action→Execution→Result\boxed{ Method \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result }$

已经形成完整的执行主链。

222.41 异常执行路径

正常：

Decision
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Completed

异常：

Decision
 ↓
Behavior
 ↓
Action
 ↓
Execution
 ↓
Failure
 ↓
Result
 ↓
Feedback
 ↓
Diagnosis
 ↓
Repair
 ↓
Execution
 ↓
Result
 ↓
Verification

Execution History 保存：

第一次执行
第二次执行

因此系统可以知道：

$Failure→Repair→SuccessFailure\rightarrow Repair\rightarrow Success$

而不是只看到最终：

Success

222.42 本章核心公式

Behavior：

$B=(G,C,A,E,R,S)\boxed{ B=(G,C,A,E,R,S) }$

Action：

$A=(T,O,C,P,R,S)\boxed{ A=(T,O,C,P,R,S) }$

Result：

$R=(Ex,Ar,S,C,T)\boxed{ R=(E_x,A_r,S,C,T) }$

Execution History：

$EH=(Ex,B,A,Sb,Sa,R,T)\boxed{ EH=(E_x,B,A,S_b,S_a,R,T) }$

Behavior与Action：

$B→{A1,A2,…,An}\boxed{ B\rightarrow\{A_1,A_2,\ldots,A_n\} }$

Action与Execution：

$Ai→{E1,E2,…,En}\boxed{ A_i\rightarrow\{E_1,E_2,\ldots,E_n\} }$

Execution与Result：

$Ex→R\boxed{ E_x\rightarrow R }$

Expected / Actual：

$C=Compare(Re,R)\boxed{ C=Compare(R_e,R) }$

有效Result：

$ValidResult=Execution∧Actual∧Comparison∧Evidence\boxed{ ValidResult = Execution \land Actual \land Comparison \land Evidence }$

222.43 本章核心原则

原则一：Behavior不是Action

$Behavior≠ActionBehavior\neq Action$

Behavior是完整行为结构，Action是具体操作。

原则二：Action不是Execution

$Action≠ExecutionAction\neq Execution$

Action是操作定义，Execution是真实执行过程。

原则三：Execution不是Result

$Execution≠ResultExecution\neq Result$

Execution描述执行过程，Result描述实际结果。

原则四：Result不是Feedback

$Result≠FeedbackResult\neq Feedback$

Result是实际结果，Feedback是结构化反馈。

原则五：Execution History不是Result

$ExecutionHistory≠ResultExecutionHistory\neq Result$

History保存执行事实及时间轨迹。

原则六：完成Execution不等于完成Goal

$ExecutionCompleted≠GoalCompletedExecutionCompleted \neq GoalCompleted$

原则七：查询不等于计算

$RepositoryQuery≠EngineCalculationRepositoryQuery\neq EngineCalculation$

原则八：历史不能被当前结果覆盖

E1 Failed
E2 Completed

两个 Execution 都必须保留。

原则九：失败不能直接删除Behavior

失败属于历史事实：

$Failure→HistoryFailure\rightarrow History$

之后是否修改 Method、Capability 或 Behavior，需要经过：

Feedback
Diagnosis
Decision
Learning
Update

原则十：Repository不承担认知推理

$Repository=Persistence\boxed{ Repository=Persistence }$ $Engine=Calculation\boxed{ Engine=Calculation }$

222.44 本章总结

第222章建立了 ICAI 执行阶段的 Repository 体系。

其核心结构为：

$BehaviorActionRepository=Behavior+Action+Result+ExecutionHistory\boxed{ BehaviorActionRepository = Behavior + Action + Result + ExecutionHistory }$

Behavior表示：

$当前完整行为\boxed{当前完整行为}$

Action表示：

$行为中的具体操作\boxed{行为中的具体操作}$

Result表示：

$真实执行产生的实际结果\boxed{真实执行产生的实际结果}$

Execution History表示：

$真实执行过程及其历史轨迹\boxed{真实执行过程及其历史轨迹}$

完整执行链：

$Method→Decision→Behavior→Action→Execution→Result\boxed{ Method \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result }$

历史链：

$Execution→ExecutionHistory\boxed{ Execution \rightarrow ExecutionHistory }$

认知反馈链：

$Result→Feedback→Memory→Experience→Learning→Update\boxed{ Result \rightarrow Feedback \rightarrow Memory \rightarrow Experience \rightarrow Learning \rightarrow Update }$

因此，到本章为止，ICAI 的 Repository 体系已经从：

Individual
 ↓
Object
 ↓
State
 ↓
Relation
 ↓
Knowledge
 ↓
Goal
 ↓
Capability
 ↓
Matching
 ↓
Method
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
Result
 ↓
Execution History

逐步形成完整的数据持久化链。

其工程边界最终可以表示为：

$DomainObject→Engine→Service→Repository→MySQL\boxed{ DomainObject \rightarrow Engine \rightarrow Service \rightarrow Repository \rightarrow MySQL }$

但真实职责关系是：

Engine
    ↓
负责计算

Service
    ↓
负责流程编排

Domain Object
    ↓
负责表达领域对象

Repository
    ↓
负责持久化与查询

MySQL
    ↓
负责实际数据存储

因此，BehaviorActionRepository 并不是把 Behavior、Action、Result、Execution 混成一个对象，而是在保持四者独立的前提下，为行为执行数据、实际结果和执行历史建立统一的持久化协作边界。

最终形成：

$Decision→Behavior→Action→Execution→Result→History\boxed{ Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow History }$

这条链是后续 FeedbackRepository、MemoryRepository、ExperienceRepository、LearningRepository 继续向认知闭环延伸的基础。

第222章 BehaviorActionRepository

第222章 BehaviorActionRepository

222.1 BehaviorActionRepository定义

222.2 Behavior领域对象

222.3 Action领域对象

222.4 Result领域对象

222.5 Execution History

222.6 Behavior与Action的关系

222.7 Behavior与Method的关系

222.8 Behavior保存

222.9 Action保存

222.10 Action Sequence

222.11 Execution与Action

222.12 Execution状态

222.13 Result保存

222.14 Execution History保存

222.15 Execution History与State History

222.16 Execution History与Feedback

222.17 Result与Feedback

222.18 BehaviorActionRepository查询

222.19 Behavior查询不等于Behavior计算

222.20 Action查询不等于Action执行

222.21 PHP接口

222.22 BehaviorMapper

222.23 ActionMapper

222.24 ResultMapper

222.25 Execution History Mapper

222.26 MySQL数据结构

222.27 一个Behavior对应多个Action

222.28 一个Action可以产生多个Execution

222.29 一个Execution产生Result

222.30 执行失败的完整历史

222.31 Repository与Memory

222.32 Repository与Experience

222.33 Repository与Learning

222.34 Behavior状态更新

222.35 Result验证

222.36 BehaviorActionRepository与事务

222.37 BehaviorActionRepository的完整PHP结构

222.38 完整执行持久化链

222.39 从执行结果进入认知闭环

222.40 与前一章MethodDecisionRepository连接

222.41 异常执行路径

222.42 本章核心公式

222.43 本章核心原则

原则一：Behavior不是Action

原则二：Action不是Execution

原则三：Execution不是Result

原则四：Result不是Feedback

原则五：Execution History不是Result

原则六：完成Execution不等于完成Goal

原则七：查询不等于计算

原则八：历史不能被当前结果覆盖

原则九：失败不能直接删除Behavior

原则十：Repository不承担认知推理

222.44 本章总结