第206章　RepairEngine——修复计算、修复执行与修复验证

206.1 RepairEngine的定义

在WSaiOS-ICAI认知工程体系中，ProtectionEngine负责风险发生前或者风险发展过程中的保护，而当系统已经产生异常、失败、错误状态或者不可接受结果以后，仅靠Protection已经不足以恢复系统。

此时必须进入Repair阶段。

因此，本章建立 RepairEngine（修复引擎）。

RepairEngine是WSaiOS-ICAI中负责根据异常、诊断结果、当前状态、历史、经验、能力、方法和修复规则，计算修复方案，组织修复动作，并根据实际执行结果验证系统是否恢复的核心Engine。

其核心定义为：

RepairEngine=RepairCalculation+RepairExecution+RepairVerificationRepairEngine= RepairCalculation+ RepairExecution+ RepairVerification

即：

RepairEngine = 修复计算 + 修复执行 + 修复验证

RepairEngine解决三个核心问题：

1. 应该如何修复？
2. 修复动作是否真正执行？
3. 修复以后系统是否真正恢复？

完整过程为：

Diagnosis→RepairCalculation→RepairAction→Execution→RepairResult→VerificationDiagnosis \rightarrow RepairCalculation \rightarrow RepairAction \rightarrow Execution \rightarrow RepairResult \rightarrow Verification

---

206.2 Repair与Protection的区别

Repair不能与Protection混淆。

Protection的核心目标是：

防止风险进一步发展或者降低风险影响。

Repair的核心目标是：

在异常或者失败已经发生以后，使系统恢复到满足条件的状态。

因此：

Risk→ProtectionRisk\rightarrow Protection

而：

Failure/Abnormality→Diagnosis→RepairFailure/Abnormality \rightarrow Diagnosis \rightarrow Repair

例如：

Resource Insufficient
→ Switch Resource

属于Protection。

如果：

Switch Resource
→ Execution Failed

并且系统进入异常状态，则：

Failure
→ Diagnosis
→ Replace Resource
→ Verification

属于Repair。

所以：

Protection≠RepairProtection\neq Repair

---

206.3 Repair的核心模型

Repair模型沿用第165章的基础定义：

Rp=(D,M,A,R,S)Rp=(D,M,A,R,S)

其中：

• RpRp：Repair，修复
• DD：Diagnosis，诊断
• MM：Repair Method，修复方法
• AA：Repair Action，修复动作
• RR：Repair Result，修复结果
• SS：Repair State，修复状态

因此：

Repair=Diagnosis+Method+Action+Result+StateRepair= Diagnosis+ Method+ Action+ Result+ State

Repair必须建立在Diagnosis之上。

没有明确异常或者诊断依据时，不能无依据执行Repair。

---

206.4 RepairEngine核心模型

RepairEngine定义为：

RE=(A,D,C,M,Ca,O,S,Ax,Ex,R,Sf,V,T)RE=(A,D,C,M,Ca,O,S,A_x,E_x,R,S_f,V,T)

为了避免变量混淆，本章统一采用以下符号：

• AA：Abnormality，异常
• DD：Diagnosis，诊断
• CC：Cause，原因
• MM：Repair Method，修复方法
• CaCa：Capability，修复能力
• OO：Object，修复对象
• SS：Current State，当前状态
• AxA_x：Repair Action，修复动作
• ExE_x：Execution，实际执行
• RR：Actual Result，实际结果
• SfS_f：Final State，修复后的最终状态
• VV：Verification，修复验证
• TT：Time，时间

因此RepairEngine的核心计算可以表示为：

RepairEngine=f(A,D,C,M,Ca,O,S,Ru,Ev,H,Ex,T)RepairEngine= f(A,D,C,M,Ca,O,S,Ru,Ev,H,Ex,T)

其中：

• RuRu：Repair Rule，修复规则
• EvEv：Evidence，证据
• HH：History，历史
• ExEx：Experience，经验

---

206.5 RepairEngine输入

RepairEngine不能只接收一个Failure字符串，而需要完整的诊断上下文。

定义：

InputR=(A,D,C,O,S,Ca,M,Ru,Ev,H,Ex,Env,T)Input_R= (A,D,C,O,S,Ca,M,Ru,Ev,H,Ex,Env,T)

其中：

• AA：当前异常
• DD：诊断结果
• CC：原因
• OO：异常对象
• SS：当前状态
• CaCa：可用能力
• MM：现有方法
• RuRu：修复规则
• EvEv：证据
• HH：历史
• ExEx：经验
• EnvEnv：环境
• TT：时间

这里特别需要强调：

DiagnosisEngine提供原因分析结果，RepairEngine使用这些原因计算修复方案。

RepairEngine不应该重新承担完整的原因诊断职责。

---

206.6 修复计算

Repair计算的第一步是判断：

当前异常是否具备修复条件？

定义：

RepairRequired=Abnormal∧DiagnosisAvailable∧RepairableRepairRequired= Abnormal \land DiagnosisAvailable \land Repairable

其中：

• AbnormalAbnormal：存在真实异常
• DiagnosisAvailableDiagnosisAvailable：存在有效诊断信息
• RepairableRepairable：存在至少一个合法修复路径

如果：

RepairRequired=FalseRepairRequired=False

则不能直接进入修复执行。

系统可能进入：

No Repair Required

或者：

Diagnosis Required

或者：

Unrecoverable

---

206.7 异常与修复条件

RepairEngine必须首先判断异常是否真实存在。

定义：

ValidAbnormality=Evidence∧Actual∧Expected∧ComparisonValidAbnormality= Evidence \land Actual \land Expected \land Comparison

其中：

• Evidence：存在证据
• Actual：存在实际结果
• Expected：存在预期结果
• Comparison：实际与预期之间存在可判断差异

如果只有：

Expected Result

而没有：

Actual Result

不能直接产生Repair。

同样，如果只有：

Failure Message

但没有可靠Evidence，也不能直接执行高风险修复。

---

206.8 诊断与修复的关系

DiagnosisEngine输出：

D=(P,Ev,C,R,S)D=(P,Ev,C,R,S)

其中：

• PP：Problem
• EvEv：Evidence
• CC：Cause
• RR：Recommendation
• SS：Diagnosis State

RepairEngine使用：

D→RepairCandidateD\rightarrow RepairCandidate

例如：

Problem:
Execution Failed

Cause:
Resource Unavailable

Recommendation:
Replace Resource

RepairEngine进一步计算：

Repair Candidate 1
→ Retry

Repair Candidate 2
→ Replace Resource

Repair Candidate 3
→ Change Method

Repair Candidate 4
→ Recover State

因此：

Diagnosis≠RepairDiagnosis\neq Repair

Diagnosis回答：

为什么出现问题？

Repair回答：

问题出现以后如何恢复？

---

206.9 修复候选

RepairEngine可以产生多个Repair Candidate。

定义：

RCi=(D,C,M,A,S,E,T)RC_i=(D,C,M,A,S,E,T)

其中：

• RCiRC_i：第 ii 个修复候选
• DD：Diagnosis
• CC：Cause
• MM：Repair Method
• AA：Repair Action
• SS：Expected State
• EE：Evidence
• TT：Time

常见修复候选包括：

Retry
Adjustment
Method Change
Action Replacement
State Recovery
Resource Replacement
Object Replacement
Environment Recovery
Rollback
Reinitialize
Recalculate
Human Review

RepairEngine首先产生候选，而不是在所有情况下自动选择第一个候选。

---

206.10 修复候选计算

修复候选必须满足：

RepairCandidateValid=Diagnosis∧Cause∧Capability∧Condition∧Resource∧RuleRepairCandidateValid= Diagnosis \land Cause \land Capability \land Condition \land Resource \land Rule

如果修复候选缺少必要能力：

Capability = unavailable

则该候选不能进入执行。

如果当前State禁止该修复：

State = blocked

也不能执行。

因此：

ExistsRepairCandidate≠ExecutableRepairExistsRepairCandidate \neq ExecutableRepair

---

206.11 修复方法

Repair Method描述如何恢复。

定义：

RM=(T,C,P,A,R)RM=(T,C,P,A,R)

其中：

• TT：Method Type
• CC：Condition
• PP：Process
• AA：Action Sequence
• RR：Expected Result

例如：

Repair Method:
Resource Replacement

Condition:
Current Resource Unavailable

Process:
1. Stop current action
2. Release invalid resource
3. Load replacement resource
4. Validate resource
5. Resume operation

Expected Result:
Resource Available

Repair Method属于Method体系。

RepairEngine负责计算和使用Repair Method，但并不取代MethodEngine。

---

206.12 修复动作

Repair Action是具体执行动作。

定义：

RA=(T,O,C,P,R,S)RA=(T,O,C,P,R,S)

其中：

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

例如：

Action:
ReplaceResource

Object:
Resource-001

Condition:
Resource-001 unavailable

Parameter:
Resource-002

Expected Result:
Resource-002 available

Expected State:
Ready

Repair Action最终交给ActionEngine处理。

因此：

RepairEngine→ActionEngineRepairEngine \rightarrow ActionEngine

---

206.13 修复执行

RepairEngine不能把“创建Repair Action”直接当成修复完成。

完整过程：

Repair→RepairAction→ActionEngine→ExecutionEngine→ActualResultRepair \rightarrow RepairAction \rightarrow ActionEngine \rightarrow ExecutionEngine \rightarrow ActualResult

RepairEngine负责组织修复执行流程。

ActionEngine负责动作计算。

ExecutionEngine负责实际运行。

因此：

RepairExecution≠ActionExecutionRepairExecution\neq ActionExecution

RepairExecution是一个业务层概念。

Actual Execution仍然属于Execution体系。

---

206.14 修复执行条件

定义：

RepairExecutable=D∧C∧Ca∧S∧Ru∧ORepairExecutable= D \land C \land Ca \land S \land Ru \land O

其中：

• DD：存在有效Diagnosis
• CC：Cause明确或者达到允许处理的诊断条件
• CaCa：修复能力可用
• SS：当前状态允许修复
• RuRu：修复规则允许
• OO：修复对象存在

只有满足：

RepairExecutable=TrueRepairExecutable=True

才能进入Repair Action。

否则：

Repair Blocked

---

206.15 修复执行状态

Repair生命周期可以定义为：

Created
→ Evaluated
→ Candidate
→ Selected
→ Ready
→ Running
→ Completed
→ Verifying
→ Verified

异常路径：

Running
→ Failed

或者：

Ready
→ Blocked

或者：

Running
→ Cancelled

需要特别区分：

Repair Completed

与：

Repair Verified

二者不是同一个状态。

---

206.16 修复结果

Repair Result表示修复动作实际执行后的结果。

定义：

RR=(Rp,A,Ex,R,Sb,Sf,C,V,T)RR=(Rp,A,E_x,R,S_b,S_f,C,V,T)

其中：

• RpRp：Repair
• AA：Repair Action
• ExE_x：Execution
• RR：Actual Result
• SbS_b：Before State
• SfS_f：Final State
• CC：Comparison
• VV：Verification
• TT：Time

因此：

RepairCreated≠RepairExecuted≠RepairSucceeded≠RepairVerifiedRepairCreated \neq RepairExecuted \neq RepairSucceeded \neq RepairVerified

例如：

Repair:
Replace Resource

Execution:
Completed

Result:
Resource replaced

State:
Still Blocked

此时：

Repair Execution = Completed

但：

Repair Success = False

因为系统并没有恢复到目标状态。

---

206.17 修复结果判断

修复结果必须比较：

SbS_b

与：

SfS_f

即：

ΔS=Compare(Sb,Sf)\Delta S= Compare(S_b,S_f)

其中：

• SbS_b：修复前状态
• SfS_f：修复后实际状态
• ΔS\Delta S：状态变化

同时比较：

ReR_e

与：

RR

其中：

• ReR_e：Expected Result，预期结果
• RR：Actual Result，实际结果

定义：

RepairResultComparison=Compare(Re,R)RepairResultComparison= Compare(R_e,R)

---

206.18 修复成功

Repair成功不能仅由Action执行成功决定。

定义：

RepairEffective=ResultMatch∧StateRecoveredRepairEffective= ResultMatch \land StateRecovered

其中：

• ResultMatchResultMatch：实际结果符合预期
• StateRecoveredStateRecovered：对象恢复到目标状态

进一步：

RepairVerified=RepairEffective∧ConditionSatisfied∧EvidenceRepairVerified= RepairEffective \land ConditionSatisfied \land Evidence

因此：

RepairExecuted≠RepairEffective≠RepairVerifiedRepairExecuted \neq RepairEffective \neq RepairVerified

---

206.19 修复状态恢复

Repair的核心目标之一是恢复State。

定义：

StateRecovered=Compare(Sf,Sexpected)=EqualStateRecovered= Compare(S_f,S_{expected})=Equal

如果：

Sf=SexpectedS_f=S_{expected}

则：

State Recovery = Success

如果：

Sf≠SexpectedS_f\neq S_{expected}

则：

State Recovery = Failed

或者：

Partially Recovered

如果只有部分属性恢复，则不能直接判定系统完全恢复。

---

206.20 修复验证

Repair Verification是RepairEngine的第三个核心部分。

定义：

Vr=Result∧State∧Condition∧EvidenceV_r= Result \land State \land Condition \land Evidence

其中：

• Result：存在实际修复结果
• State：存在修复后的实际状态
• Condition：修复条件满足
• Evidence：存在有效验证证据

只有：

Vr=TrueV_r=True

才能将Repair标记为Verified。

---

206.21 修复验证层次

Repair Verification可以分成多个层级。

第一层：动作验证

检查：

Repair Action是否执行。

第二层：结果验证

检查：

Actual Result是否符合Expected Result。

第三层：状态验证

检查：

Object是否进入目标State。

第四层：问题验证

检查：

原始Abnormality是否消失。

第五层：系统验证

检查：

修复以后系统是否能够继续正常运行。

因此完整验证：

Action→Result→State→Abnormality→SystemAction \rightarrow Result \rightarrow State \rightarrow Abnormality \rightarrow System

---

206.22 修复验证不能只看结果

例如：

Expected:
Resource Available

Actual:
Resource Available

结果看起来正常。

但是：

System State:
Blocked

那么Repair不能直接判定为Verified。

因为Repair的最终目标不是让一个字段变成目标值，而是使整个相关对象或者系统恢复到合法状态。

因此：

RepairVerification=ResultVerification+StateVerification+ConditionVerification+EvidenceVerificationRepairVerification = ResultVerification + StateVerification + ConditionVerification + EvidenceVerification

---

206.23 修复失败

如果：

RepairVerified=FalseRepairVerified=False

RepairEngine不能直接无限Retry。

应该进入：

Repair Failed
→ Analyze Failure
→ New Repair Candidate
→ Decision

如果失败原因已经明确：

Repair Failure
→ Diagnosis Update
→ New Repair Method

如果没有可行方案：

Repair Failed
→ Unrecoverable
→ Human Review

---

206.24 Retry必须受到控制

Repair系统不能简单使用：

while (!$success) {
    repair();
}

因为这种设计可能产生无限修复循环。

必须建立：

RetryAllowed=RetryCount<RetryLimit∧CauseStillRepairable∧StateAllowsRetryAllowed= RetryCount<RetryLimit \land CauseStillRepairable \land StateAllows

例如：

RetryCount = 0
RetryLimit = 3

则最多允许三次相同类型Retry。

如果：

RetryCount≥RetryLimitRetryCount\geq RetryLimit

则进入：

Retry Exhausted

然后重新诊断或者更换Repair Method。

---

206.25 修复计算评分

当存在多个Repair Candidate时，可以使用确定性评分。

定义：

RepairScore(Ci)=WsSi+WrRi+WcCi+WeEi+WvViRepairScore(C_i)= W_sS_i+ W_rR_i+ W_cC_i+ W_eE_i+ W_vV_i

其中：

• SiS_i：Safety，安全性
• RiR_i：Recovery Probability，历史验证恢复能力
• CiC_i：Cost，修复成本反向评分
• EiE_i：Evidence，证据充分程度
• ViV_i：Verification，验证可靠程度
• Ws,Wr,Wc,We,WvW_s,W_r,W_c,W_e,W_v：各维度权重

这里的评分是确定性计算。

RepairEngine可以负责生成和评分候选。

当多个候选存在最终选择问题时：

RepairCandidates→DecisionEngineRepairCandidates \rightarrow DecisionEngine

---

206.26 修复能力

Repair本身也需要Capability。

例如：

Capability:
Replace Resource

State:
Available

Range:
Resource Type A/B/C

Verification:
Previously Verified

RepairEngine必须检查：

CapabilityAvailable=Type∧Condition∧State∧RangeCapabilityAvailable= Type \land Condition \land State \land Range

如果修复能力不存在：

Repair Candidate
→ Blocked

不能因为Diagnosis认为“应该替换资源”，就假设系统一定具备替换能力。

---

206.27 修复方法与方法Engine

RepairEngine与MethodEngine关系：

RepairEngine
    ↓
Repair Method Candidate
    ↓
MethodEngine
    ↓
Method Calculation
    ↓
Method Validation
    ↓
Action Sequence

RepairEngine负责：

从Diagnosis和Cause出发寻找适合的修复方向。

MethodEngine负责：

计算该修复方法的具体过程和动作结构。

因此：

RepairEngine≠MethodEngineRepairEngine\neq MethodEngine

---

206.28 RepairEngine与ActionEngine

关系：

RepairEngine→RepairAction→ActionEngineRepairEngine \rightarrow RepairAction \rightarrow ActionEngine

RepairEngine产生：

ReplaceResource

ActionEngine计算：

Target = Resource-001
Parameter = Resource-002
Condition = Resource-001 unavailable
Expected Result = Resource-002 available

因此RepairEngine负责Repair语义。

ActionEngine负责Action结构。

---

206.29 RepairEngine与ExecutionEngine

ExecutionEngine负责实际发生。

例如：

RepairEngine:
Replace Resource

ActionEngine:
Build ReplaceResource Action

ExecutionEngine:
Execute ReplaceResource

Actual:
Resource-002 loaded

因此：

RepairExecution=RepairContext+ActualExecutionRepairExecution = RepairContext + ActualExecution

RepairEngine不能伪造Execution Result。

所有Repair Result必须来源于实际Execution。

---

206.30 RepairEngine与FeedbackEngine

Repair执行完成以后：

Execution→Result→FeedbackExecution \rightarrow Result \rightarrow Feedback

FeedbackEngine负责将结果结构化。

RepairEngine再使用Feedback进行：

Repair Result
→ State Update
→ Verification

因此：

RepairEngine←FeedbackEngineRepairEngine \leftarrow FeedbackEngine

这形成闭环。

---

206.31 RepairEngine与StateEngine

Repair通常会产生状态恢复。

例如：

Blocked
→ Recovering
→ Ready

RepairEngine不能直接修改State。

正确结构：

RepairEngine→StateEngine→StateServiceRepairEngine \rightarrow StateEngine \rightarrow StateService

RepairEngine产生：

StateTransitionCandidateStateTransitionCandidate

StateEngine判断：

Transition(St,Event,Co,Ru)→St+1Transition(S_t,Event,Co,Ru)\rightarrow S_{t+1}

只有合法状态转换才能保存。

---

206.32 RepairEngine与ProtectionEngine

两者形成前后关系：

Risk→ProtectionRisk \rightarrow Protection

如果Protection成功：

Risk Controlled

如果Protection失败并形成实际异常：

Failure→Diagnosis→RepairFailure \rightarrow Diagnosis \rightarrow Repair

因此：

Risk
 ↓
Protection
 ↓
Protection Failed
 ↓
Abnormality
 ↓
Diagnosis
 ↓
Repair

RepairEngine属于异常恢复层。

ProtectionEngine属于风险预防和风险控制层。

---

206.33 RepairEngine与DiagnosisEngine

二者之间的关系最直接：

Diagnosis→RepairDiagnosis \rightarrow Repair

DiagnosisEngine输出：

Problem
Cause
Evidence
Recommendation

RepairEngine输入这些数据并计算：

Repair Method
Repair Candidate
Repair Action
Repair Result

因此：

DiagnosisEngine回答“为什么”。

RepairEngine回答“怎么恢复”。

---

206.34 RepairEngine完整PHP计算实现

下面给出与前面Engine体系兼容的PHP 5.6/7实现。

<?php

abstract class Engine
{
    public function calculate($input)
    {
        return array();
    }
}

class RepairEngine extends Engine
{
    public function calculate($input)
    {
        $abnormality = isset($input['abnormality'])
            ? $input['abnormality']
            : array();

        $diagnosis = isset($input['diagnosis'])
            ? $input['diagnosis']
            : array();

        $cause = isset($input['cause'])
            ? $input['cause']
            : array();

        $object = isset($input['object'])
            ? $input['object']
            : array();

        $state = isset($input['state'])
            ? $input['state']
            : array();

        $capability = isset($input['capability'])
            ? $input['capability']
            : array();

        $rules = isset($input['rules'])
            ? $input['rules']
            : array();

        $evidence = isset($input['evidence'])
            ? $input['evidence']
            : array();

        $time = isset($input['time'])
            ? $input['time']
            : time();

        $repairRequired = $this->isRepairRequired(
            $abnormality,
            $diagnosis
        );

        if (!$repairRequired) {
            return array(
                'status' => 'repair_not_required',
                'repair_required' => false,
                'time' => $time
            );
        }

        $candidates = $this->buildRepairCandidates(
            $abnormality,
            $diagnosis,
            $cause,
            $object,
            $state,
            $capability,
            $rules
        );

        $validCandidates = array();

        foreach ($candidates as $candidate) {
            if ($this->validateCandidate($candidate)) {
                $candidate['score'] =
                    $this->calculateRepairScore(
                        $candidate,
                        $evidence
                    );

                $validCandidates[] = $candidate;
            }
        }

        usort(
            $validCandidates,
            array($this, 'compareCandidate')
        );

        return array(
            'status' => 'repair_candidates_created',
            'repair_required' => true,
            'candidates' => $validCandidates,
            'diagnosis' => $diagnosis,
            'cause' => $cause,
            'time' => $time
        );
    }

    public function isRepairRequired(
        $abnormality,
        $diagnosis
    ) {
        $abnormal =
            !empty($abnormality) &&
            isset($abnormality['status']) &&
            $abnormality['status'] != 'normal';

        $diagnosisAvailable =
            !empty($diagnosis) &&
            isset($diagnosis['state']);

        return $abnormal && $diagnosisAvailable;
    }

    public function buildRepairCandidates(
        $abnormality,
        $diagnosis,
        $cause,
        $object,
        $state,
        $capability,
        $rules
    ) {
        $candidates = array();

        $causeType = isset($cause['type'])
            ? strtolower($cause['type'])
            : '';

        switch ($causeType) {

            case 'resource':
                $candidates[] = $this->createCandidate(
                    'resource_replacement',
                    'Replace unavailable resource',
                    $object
                );

                $candidates[] = $this->createCandidate(
                    'resource_recovery',
                    'Recover resource state',
                    $object
                );
                break;

            case 'method':
                $candidates[] = $this->createCandidate(
                    'method_change',
                    'Change current method',
                    $object
                );
                break;

            case 'state':
                $candidates[] = $this->createCandidate(
                    'state_recovery',
                    'Recover object state',
                    $object
                );
                break;

            case 'action':
                $candidates[] = $this->createCandidate(
                    'action_replacement',
                    'Replace failed action',
                    $object
                );
                break;

            case 'environment':
                $candidates[] = $this->createCandidate(
                    'environment_recovery',
                    'Recover environment condition',
                    $object
                );
                break;

            default:
                $candidates[] = $this->createCandidate(
                    'retry',
                    'Retry previous method',
                    $object
                );

                $candidates[] = $this->createCandidate(
                    'recalculate',
                    'Recalculate execution condition',
                    $object
                );
        }

        return $candidates;
    }

    protected function createCandidate(
        $type,
        $description,
        $object
    ) {
        return array(
            'type' => $type,
            'description' => $description,
            'object_id' => isset($object['id'])
                ? $object['id']
                : null,
            'state' => 'candidate'
        );
    }

    public function validateCandidate($candidate)
    {
        if (!isset($candidate['type'])) {
            return false;
        }

        if (!isset($candidate['object_id'])) {
            return false;
        }

        return true;
    }

    public function calculateRepairScore(
        $candidate,
        $evidence
    ) {
        $score = 50;

        if (!empty($evidence)) {
            $score += 20;
        }

        switch ($candidate['type']) {

            case 'state_recovery':
                $score += 15;
                break;

            case 'resource_replacement':
                $score += 14;
                break;

            case 'action_replacement':
                $score += 12;
                break;

            case 'method_change':
                $score += 10;
                break;

            case 'environment_recovery':
                $score += 9;
                break;

            case 'retry':
                $score += 5;
                break;
        }

        return $score;
    }

    public function compareCandidate($a, $b)
    {
        if ($a['score'] == $b['score']) {
            return 0;
        }

        return ($a['score'] > $b['score'])
            ? -1
            : 1;
    }

    public function validateRepairExecution(
        $diagnosis,
        $cause,
        $capability,
        $state,
        $rule,
        $object
    ) {
        $validDiagnosis = !empty($diagnosis);
        $validCause = !empty($cause);
        $validCapability = !empty($capability);
        $validState = !empty($state);
        $validRule = !empty($rule);
        $validObject = !empty($object);

        return
            $validDiagnosis &&
            $validCause &&
            $validCapability &&
            $validState &&
            $validRule &&
            $validObject;
    }

    public function calculateRepairResult(
        $repair,
        $action,
        $execution,
        $expectedResult,
        $actualResult,
        $beforeState,
        $afterState,
        $expectedState,
        $evidence
    ) {
        $resultMatch = $this->compareValue(
            $expectedResult,
            $actualResult
        );

        $stateRecovered = $this->compareValue(
            $expectedState,
            $afterState
        );

        $effective =
            $resultMatch &&
            $stateRecovered;

        $verified =
            $effective &&
            !empty($evidence);

        if ($verified) {
            $status = 'verified';
        } elseif ($effective) {
            $status = 'effective';
        } elseif ($resultMatch || $stateRecovered) {
            $status = 'partially_recovered';
        } else {
            $status = 'failed';
        }

        return array(
            'repair' => $repair,
            'action' => $action,
            'execution' => $execution,
            'expected_result' => $expectedResult,
            'actual_result' => $actualResult,
            'before_state' => $beforeState,
            'after_state' => $afterState,
            'expected_state' => $expectedState,
            'result_match' => $resultMatch,
            'state_recovered' => $stateRecovered,
            'effective' => $effective,
            'verified' => $verified,
            'status' => $status,
            'evidence' => $evidence
        );
    }

    protected function compareValue(
        $expected,
        $actual
    ) {
        if (is_array($expected) && is_array($actual)) {
            return $expected == $actual;
        }

        return $expected === $actual;
    }
}

该实现完成了三个核心阶段：

calculate()
→ 修复需求判断 + 修复候选计算

buildRepairCandidates()
→ 修复方案生成

calculateRepairResult()
→ 修复结果 + 状态恢复 + 验证判断

同时保留：

validateRepairExecution()

用于修复执行前的条件检查。

---

206.35 修复结果计算示例

例如：

$engine = new RepairEngine();

$input = array(
    'abnormality' => array(
        'status' => 'failure'
    ),
    'diagnosis' => array(
        'state' => 'cause_found'
    ),
    'cause' => array(
        'type' => 'resource'
    ),
    'object' => array(
        'id' => 1001
    ),
    'state' => array(
        'value' => 'blocked'
    ),
    'capability' => array(
        'replace_resource' => true
    ),
    'rules' => array(
        'repair_allowed' => true
    ),
    'evidence' => array(
        'source' => 'execution'
    )
);

$result = $engine->calculate($input);

其计算路径为：

Abnormality
→ Diagnosis
→ Cause = Resource
→ Repair Candidate
→ Resource Replacement
→ Candidate Score
→ Candidate Ranking

随后由DecisionEngine或者RepairService选择具体Repair Candidate。

---

206.36 完整修复结果示例

修复执行完成以后，可以调用：

$repairResult = $engine->calculateRepairResult(
    array(
        'id' => 501,
        'type' => 'resource_replacement'
    ),
    array(
        'type' => 'replace_resource'
    ),
    array(
        'id' => 9001,
        'state' => 'completed'
    ),
    array(
        'resource_state' => 'available'
    ),
    array(
        'resource_state' => 'available'
    ),
    array(
        'state' => 'blocked'
    ),
    array(
        'state' => 'ready'
    ),
    array(
        'state' => 'ready'
    ),
    array(
        'source' => 'execution',
        'verified' => true
    )
);

计算结果的核心判断：

Expected Result = Actual Result
        ↓
Result Match

Expected State = Actual State
        ↓
State Recovered

Evidence Exists
        ↓
Verified

最终：

status = verified

---

206.37 修复数据库结构

RepairEngine建议对应以下数据表。

repairs

id
diagnosis_id
object_id
repair_type
repair_method_id
state
priority
created_at
updated_at

repair_candidates

id
repair_id
candidate_type
description
score
state
reason
created_at

repair_actions

id
repair_id
action_type
object_id
parameters
expected_result
expected_state
state
created_at

repair_executions

id
repair_action_id
execution_id
started_at
finished_at
state

repair_results

id
repair_id
action_id
execution_id
expected_result
actual_result
before_state
after_state
expected_state
result_match
state_recovered
effective
verified
status
created_at

repair_verifications

id
repair_result_id
verification_type
evidence
result
status
verified_at

repair_history

id
repair_id
event_type
old_state
new_state
reason
created_at

形成：

Diagnosis→Repair→RepairAction→Execution→RepairResult→VerificationDiagnosis \rightarrow Repair \rightarrow RepairAction \rightarrow Execution \rightarrow RepairResult \rightarrow Verification

---

206.38 RepairEngine与Service层

RepairEngine负责计算。

RepairService负责业务编排。

完整架构：

Controller
    ↓
RepairService
    ↓
DiagnosisService
    ↓
RepairEngine
    ↓
DecisionService
    ↓
ActionService
    ↓
ActionEngine
    ↓
ExecutionService
    ↓
ExecutionEngine
    ↓
FeedbackService
    ↓
FeedbackEngine
    ↓
RepairEngine
    ↓
Verification
    ↓
StateService
    ↓
Repository
    ↓
MySQL

RepairService主要负责：

1. 加载Abnormality
2. 加载Diagnosis
3. 加载Cause
4. 加载Object
5. 加载Current State
6. 加载Capability
7. 调用RepairEngine
8. 保存Repair Candidate
9. 调用DecisionService
10. 建立Repair Action
11. 调用ActionService
12. 获取Execution Result
13. 接收Feedback
14. 调用Repair Verification
15. 更新State
16. 保存Repair History

---

206.39 RepairEngine事务边界

Repair过程可能涉及多个数据库操作。

例如：

Create Repair
→ Create Candidate
→ Select Candidate
→ Create Action
→ Create Execution Record
→ Save Result
→ Save Verification
→ Update State

数据库可以使用事务：

Begin→RepairProcess→CommitBegin \rightarrow RepairProcess \rightarrow Commit

发生数据库异常：

RollbackRollback

但是必须明确：

数据库Rollback不能撤销已经发生的外部实际动作。

例如：

External Resource
→ Already Replaced

即使MySQL事务Rollback，也不能假装资源从未被替换。

因此：

DBRollback≠WorldRollbackDBRollback \neq WorldRollback

这是RepairEngine工程设计中必须保留的边界。

---

206.40 修复历史

RepairHistory必须保存实际发生过的修复事实。

例如：

Diagnosis Created
Repair Candidate Created
Repair Selected
Repair Started
Repair Completed
Repair Failed
Repair Verified
Repair Rejected
Repair Repeated
Repair Escalated

历史结构：

Hr=(T,O,A,R,S,C)H_r=(T,O,A,R,S,C)

其中：

• TT：时间
• OO：对象
• AA：动作
• RR：结果
• SS：状态
• CC：上下文

历史不能被后续学习结果覆盖。

历史表示：

当时实际发生了什么。

---

206.41 Repair与Memory

Repair完成以后，其历史可以进入MemoryEngine。

例如：

Failure
→ Cause
→ Repair Method
→ Repair Action
→ Result
→ Verification

形成可检索记忆：

Memory:
Object X 在 Condition Y 下出现 Failure Z，
使用 Repair Method M 后恢复成功。

MemoryEngine负责：

MemoryCalculation+MemoryRecall+MemoryUpdateMemoryCalculation + MemoryRecall + MemoryUpdate

RepairEngine负责提供真实Repair事实。

---

206.42 Repair与Experience

经过多次历史比较，可以形成Experience。

例如：

Experience=Condition+Failure+Cause+Repair+Result+VerificationExperience= Condition+ Failure+ Cause+ Repair+ Result+ Verification

形成：

Condition A
→ Failure B
→ Cause C
→ Repair D
→ Verified Success

以后再次出现：

Condition A + Failure B

RepairEngine可以把该Experience作为Repair Candidate计算依据。

但是：

Experience≠RepairRuleExperience\neq RepairRule

经验不能直接替代规则。

---

206.43 Repair与Learning

Repair结果经过Verification以后，可以成为Learning Data。

定义：

LearningData=RepairResult+Comparison+VerificationLearningData= RepairResult+ Comparison+ Verification

只有经过验证的修复结果才能成为高可信学习数据。

例如：

Repair Method A
→ 3次执行
→ 3次恢复
→ 3次验证通过

这类数据可以支持后续Method、Capability、Decision或Rule更新。

而：

Repair Method B
→ 1次失败

不能直接得出：

Method B 永远无效

因此Learning仍然遵循：

Evidence∧Valid∧Verified∧ApplicableEvidence \land Valid \land Verified \land Applicable

---

206.44 修复失败后的再诊断

如果Repair失败：

RepairVerified=FalseRepairVerified=False

不能简单得出：

Cause = Wrong

因为可能存在：

• 修复动作错误
• 修复条件变化
• 能力不足
• 环境变化
• 新风险出现
• 原因判断不完整
• 多重原因
• 状态转换失败

因此：

Repair Failure
→ Feedback
→ Abnormality Update
→ Diagnosis Re-evaluation

重新进入DiagnosisEngine。

---

206.45 多原因修复

实际系统中，一个异常可能存在多个原因。

例如：

Failure
├── Resource Unavailable
├── Method Invalid
└── Environment Changed

此时：

Cause={C1,C2,C3}Cause=\{C_1,C_2,C_3\}

RepairEngine可以生成：

Repair Candidate 1
→ Replace Resource

Repair Candidate 2
→ Change Method

Repair Candidate 3
→ Recover Environment

如果多个原因必须同时处理：

RepairSet={R1,R2,R3}RepairSet= \{R_1,R_2,R_3\}

则需要检查：

• 执行顺序
• 依赖
• 资源冲突
• 状态条件
• 方法兼容性

必要时交给MethodEngine进行组合。

---

206.46 修复组合

多个Repair可以组合成Repair Plan：

RP=(R1,R2,…,Rn)RP=(R_1,R_2,\ldots,R_n)

例如：

Repair Plan
1. Stop failed action
2. Recover resource
3. Reset state
4. Validate resource
5. Retry method
6. Verify final state

组合必须满足：

Order∧Dependency∧Condition∧Capability∧ResourceOrder \land Dependency \land Condition \land Capability \land Resource

否则不能直接执行。

Repair Plan仍然需要最终验证。

---

206.47 RepairEngine的确定性

RepairEngine必须保持确定性。

同样的：

Abnormality
+
Diagnosis
+
Cause
+
State
+
Capability
+
Rule

在规则不变的情况下，应产生一致的Repair Candidate计算结果。

即：

RE(X,Ru)=RE(X,Ru)RE(X,Ru)=RE(X,Ru)

RepairEngine不依赖：

• LLM
• Transformer
• Embedding
• Vector Search
• Prompt Engineering
• Neural Network
• LLM API

其核心机制是：

对象
+
状态
+
规则
+
条件
+
能力
+
方法
+
历史
+
经验
+
证据

通过离散计算、条件判断、规则匹配、评分、排序和状态转换完成修复计算。

---

206.48 RepairEngine解释链

RepairEngine必须能够回答：

为什么需要修复？

因为：

Actual Result
≠
Expected Result

并且：

Abnormality
= Valid

继续：

为什么选择这个修复？

因为：

Diagnosis
→ Cause
→ Repair Candidate
→ Capability
→ Condition
→ Rule
→ Score

继续：

修复真的执行了吗？

查看：

Execution

继续：

修复成功了吗？

查看：

Actual Result
+
Final State

最后：

为什么认为已经恢复？

查看：

Verification
+
Evidence

完整解释链：

Abnormality→Diagnosis→Cause→RepairCandidate→Action→Execution→Result→State→VerificationAbnormality \rightarrow Diagnosis \rightarrow Cause \rightarrow RepairCandidate \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow State \rightarrow Verification

---

206.49 RepairEngine完整闭环

正常修复：

Abnormality
→ Diagnosis
→ Cause
→ Repair Calculation
→ Repair Candidate
→ Decision
→ Repair Method
→ Repair Action
→ ActionEngine
→ ExecutionEngine
→ Actual Result
→ FeedbackEngine
→ StateEngine
→ Repair Verification
→ Recovered

修复失败：

Abnormality
→ Diagnosis
→ Repair
→ Execution
→ Failure
→ Feedback
→ Diagnosis Re-evaluation
→ New Repair Candidate
→ Decision
→ New Repair

无法修复：

Repair Failure
→ Retry Exhausted
→ No Valid Repair
→ Unrecoverable
→ Human Review

---

206.50 RepairEngine在ICAI体系中的位置

目前Engine体系可以进一步形成：

ObjectEngine
      ↓
StateEngine
      ↓
RelationEngine
      ↓
SceneEngine
      ↓
KnowledgeEngine
      ↓
CapabilityEngine
      ↓
MatchingEngine
      ↓
MethodEngine
      ↓
DecisionEngine
      ↓
BehaviorEngine
      ↓
ActionEngine
      ↓
ExecutionEngine
      ↓
FeedbackEngine
      ↓
RiskEngine
      ↓
ConflictEngine
      ↓
ProtectionEngine
      ↓
DiagnosisEngine
      ↓
RepairEngine
      ↓
MemoryEngine
      ↓
ExperienceEngine
      ↓
LearningEngine

其中：

Risk→ProtectionRisk \rightarrow Protection

负责预防。

Abnormality→DiagnosisAbnormality \rightarrow Diagnosis

负责原因分析。

Diagnosis→RepairDiagnosis \rightarrow Repair

负责恢复。

因此：

Risk
 ↓
Protection
 ↓
Failure
 ↓
Diagnosis
 ↓
Repair
 ↓
Verification
 ↓
Recovery

形成完整的问题处理链。

---

206.51 RepairEngine统一数学模型

最终将RepairEngine表示为：

RE=f(A,D,C,O,S,Ca,M,Ru,Ev,H,Ex,Env,T)RE= f(A,D,C,O,S,Ca,M,Ru,Ev,H,Ex,Env,T)

输出：

RE→(RC,RA,Ex,RR,V)RE \rightarrow (RC,RA,E_x,RR,V)

其中：

• RCRC：Repair Candidate
• RARA：Repair Action
• ExE_x：Execution
• RRRR：Repair Result
• VV：Verification

完整过程：

Abnormality→Diagnosis→Cause→RepairCalculationAbnormality \rightarrow Diagnosis \rightarrow Cause \rightarrow RepairCalculation

然后：

RepairCalculation→RepairCandidate→Decision→RepairActionRepairCalculation \rightarrow RepairCandidate \rightarrow Decision \rightarrow RepairAction

再：

RepairAction→Execution→ResultRepairAction \rightarrow Execution \rightarrow Result

最后：

Result→StateRecovery→VerificationResult \rightarrow StateRecovery \rightarrow Verification

最终形成：

Abnormality→Diagnosis→Repair→Execution→Verification→Recovery\boxed{ Abnormality \rightarrow Diagnosis \rightarrow Repair \rightarrow Execution \rightarrow Verification \rightarrow Recovery }

---

206.52 本章总结

RepairEngine是WSaiOS-ICAI异常恢复体系中的核心Engine。

其核心定义：

RepairEngine=RepairCalculation+RepairExecution+RepairVerificationRepairEngine= RepairCalculation+ RepairExecution+ RepairVerification

修复计算首先判断：

RepairRequired=Abnormal∧DiagnosisAvailable∧RepairableRepairRequired= Abnormal \land DiagnosisAvailable \land Repairable

然后：

Diagnosis→Cause→RepairCandidateDiagnosis \rightarrow Cause \rightarrow RepairCandidate

通过Capability、Condition、State、Rule和Evidence进行候选验证。

选定修复方案以后：

Repair→RepairAction→ActionEngine→ExecutionEngineRepair \rightarrow RepairAction \rightarrow ActionEngine \rightarrow ExecutionEngine

获得实际结果：

Execution→ActualResultExecution \rightarrow ActualResult

再比较：

Compare(ExpectedResult,ActualResult)Compare(ExpectedResult,ActualResult)

以及：

Compare(ExpectedState,ActualState)Compare(ExpectedState,ActualState)

最终：

RepairEffective=ResultMatch∧StateRecoveredRepairEffective= ResultMatch \land StateRecovered

进一步：

RepairVerified=RepairEffective∧ConditionSatisfied∧EvidenceRepairVerified= RepairEffective \land ConditionSatisfied \land Evidence

因此必须明确：

RepairExecuted≠RepairSucceeded≠RepairVerifiedRepairExecuted \neq RepairSucceeded \neq RepairVerified

修复成功不是由“动作执行完成”决定，而是由：

实际结果 + 状态恢复 + 条件满足 + 证据验证

共同决定。

最终完整闭环为：

Risk
→ Protection
→ Abnormality
→ Diagnosis
→ Cause
→ Repair Calculation
→ Repair Candidate
→ Decision
→ Repair Action
→ ActionEngine
→ ExecutionEngine
→ Actual Result
→ FeedbackEngine
→ StateEngine
→ Repair Verification
→ Recovery
→ Memory
→ Experience
→ Learning
→ Knowledge / Capability / Method Update
→ New Decision

因此，RepairEngine在WSaiOS-ICAI中的根本作用不是简单执行一个“修复函数”，而是建立一套能够被计算、执行、验证、记录、复用和学习的结构化异常恢复机制。

其最终核心原则为：

Diagnosis tells Why;Repair calculates How;Execution produces Actual;Verification proves Recovery\boxed{ Diagnosis\ tells\ Why; Repair\ calculates\ How; Execution\ produces\ Actual; Verification\ proves\ Recovery }

即：

诊断解释为什么发生问题，修复计算如何恢复，执行产生实际结果，验证证明系统是否真正恢复。

1. 统一 Repair 状态模型

将 Repair 状态定义为：

RS∈{Created,Evaluated,Candidate,Selected,Ready,Running,Completed,Verifying,Verified,Failed,Blocked,Cancelled,Unrecoverable}RS \in \{ Created, Evaluated, Candidate, Selected, Ready, Running, Completed, Verifying, Verified, Failed, Blocked, Cancelled, Unrecoverable \}

各状态定义如下：

状态	定义
Created	修复记录已经创建，但尚未完成修复条件计算
Evaluated	已完成异常、诊断、原因、能力、条件等修复可行性计算
Candidate	已产生一个或多个修复候选方案
Selected	已确定具体修复方案
Ready	修复条件满足，可以执行
Running	修复动作正在实际执行
Completed	修复执行过程已经结束，但尚未判断恢复是否成功
Verifying	已获得实际结果，正在进行修复验证
Verified	修复结果、状态恢复、条件和证据均验证通过
Failed	修复执行或修复结果未达到要求
Blocked	因能力、状态、资源、规则或条件不满足而不能执行
Cancelled	修复过程被明确取消
Unrecoverable	当前条件下不存在有效修复路径，或者允许的修复方案全部失败

因此标准生命周期统一为：

Created
  ↓
Evaluated
  ↓
Candidate
  ↓
Selected
  ↓
Ready
  ↓
Running
  ↓
Completed
  ↓
Verifying
  ↓
Verified

异常路径：

Evaluated → Blocked
Candidate → Blocked
Ready → Cancelled
Running → Failed
Verifying → Failed
Failed → Evaluated
Failed → Unrecoverable

这里有一个重要原则：

Completed 不等于 Verified。

Completed只表示“修复执行已经结束”；Verified才表示“修复已经被证明有效”。

---

2. 统一 Repair Verification 定义

将修复验证统一定义为：

RV=(R,S,C,Ev,T)RV=(R,S,C,Ev,T)

其中：

• RR：Actual Repair Result，实际修复结果
• SS：Recovered State，修复后的实际状态
• CC：Repair Condition，修复条件
• EvEv：Evidence，验证证据
• TT：Verification Time，验证时间

因此：

RepairVerified=ResultVerified∧StateVerified∧ConditionVerified∧EvidenceVerifiedRepairVerified = ResultVerified \land StateVerified \land ConditionVerified \land EvidenceVerified

四项全部成立，才能进入：

VerifiedVerified

---

3. 统一四层验证

Repair Verification以后统一分成四个层次。

第一层：Execution Verification

确认修复动作是否实际完成：

VE=ActualExecution∧ExecutionResultV_E=ActualExecution \land ExecutionResult

它回答：

修复动作有没有真正执行？

---

第二层：Result Verification

比较预期结果与实际结果：

VR=Compare(Re,R)=EqualV_R= Compare(R_e,R)=Equal

其中：

• ReR_e：Expected Result，预期结果
• RR：Actual Result，实际结果

它回答：

修复产生的实际结果是否符合预期？

---

第三层：State Verification

比较目标状态和实际恢复状态：

VS=Compare(Se,Sf)=EqualV_S= Compare(S_e,S_f)=Equal

其中：

• SeS_e：Expected State，预期恢复状态
• SfS_f：Final State，实际最终状态

它回答：

对象是否真正恢复到了目标状态？

---

第四层：Evidence Verification

确认以上判断具有有效证据：

VEv=Valid(Ev)V_{Ev}=Valid(Ev)

它回答：

为什么可以证明这个修复确实成功？

---

4. 最终统一验证公式

因此RepairEngine统一使用：

VRepair=VE∧VR∧VS∧VC∧VEv\boxed{ V_{Repair} = V_E \land V_R \land V_S \land V_C \land V_{Ev} }

其中：

• VEV_E：Execution Verification
• VRV_R：Result Verification
• VSV_S：State Verification
• VCV_C：Condition Verification
• VEvV_{Ev}：Evidence Verification

也就是：

RepairVerified=Execution∧Result∧State∧Condition∧Evidence\boxed{ RepairVerified= Execution \land Result \land State \land Condition \land Evidence }

---

5. 统一 Repair Result 状态

为了避免把“执行状态”和“验证状态”混在一起，建议以后不要再定义大量类似：

effective
successful
recovered
verified

作为并列的Repair生命周期状态。

统一采用：

RepairStateRepairState

负责描述Repair生命周期。

同时：

VerificationResultVerificationResult

负责描述验证结果。

例如：

RepairState = Completed
VerificationResult = Failed

表示：

修复动作执行结束了，但验证失败。

而：

RepairState = Verifying
VerificationResult = Pending

表示：

已经执行完成，目前正在验证。

最终：

RepairState = Verified
VerificationResult = Passed

表示：

修复已经被验证为有效。

---

6. 统一 Verification Result

验证结果统一定义：

Pending
Passed
Failed
Partial
Unknown
Invalid
Expired
Conflicted

其含义：

VerificationResult	含义
Pending	尚未完成验证
Passed	全部必要验证通过
Failed	必要验证失败
Partial	部分验证通过，但尚不足以确认恢复
Unknown	当前证据不足，无法判断
Invalid	验证数据或证据无效
Expired	原验证结果已经超过有效时间
Conflicted	不同证据或状态产生冲突

这样就形成两个严格分离的维度：

RepairStateRepairState

和：

VerificationResultVerificationResult

---

7. 统一 Repair 状态与验证关系

最终关系固定为：

RepairState
    ↓
Completed
    ↓
Verifying
    ↓
VerificationResult
    ↓
Passed / Failed / Partial / Unknown

只有：

RepairState=VerifyingRepairState=Verifying

以后才允许进入最终验证判断。

验证通过：

VerificationResult=PassedVerificationResult=Passed

则：

RepairState=VerifiedRepairState=Verified

验证失败：

VerificationResult=FailedVerificationResult=Failed

则：

RepairState=FailedRepairState=Failed

部分恢复：

VerificationResult=PartialVerificationResult=Partial

则不能进入 Verified，应该重新进入：

Evaluated
→ Candidate
→ Selected

或者进入新的Diagnosis。

---

8. 与DiagnosisEngine统一

Diagnosis状态仍然负责：

Unknown
→ Detected
→ Analyzing
→ CauseFound
→ Confirmed
→ Resolved

Repair不要重复使用这些状态。

因此：

DiagnosisState≠RepairStateDiagnosisState\neq RepairState

关系为：

Abnormality
    ↓
Diagnosis
    ↓
CauseFound / Confirmed
    ↓
Repair Created
    ↓
Repair Evaluated

Diagnosis解决：

原因是否已经找到？

Repair解决：

如何恢复？

---

9. 与ProtectionEngine统一

Protection继续使用自己的生命周期：

Created
→ Ready
→ Running
→ Completed
→ Verifying
→ Verified

但语义不同。

Protection：

风险是否被控制？

Repair：

异常是否被恢复？

所以虽然生命周期结构可以保持相似，但对象语义必须区分：

ProtectionVerified≠RepairVerifiedProtectionVerified \neq RepairVerified

前者：

RiskReduced∧SafeState∧EvidenceRiskReduced\land SafeState\land Evidence

后者：

ProblemResolved∧StateRecovered∧EvidenceProblemResolved\land StateRecovered\land Evidence

---

10. 修复验证最终标准

以后第206章以及后续Repair相关章节统一采用下面这个标准：

RepairVerified=ActualExecution∧ResultMatch∧StateRecovered∧ConditionSatisfied∧ValidEvidence\boxed{ RepairVerified = ActualExecution \land ResultMatch \land StateRecovered \land ConditionSatisfied \land ValidEvidence }

其中：

ResultMatch=Compare(Re,R)=EqualResultMatch=Compare(R_e,R)=Equal StateRecovered=Compare(Se,Sf)=EqualStateRecovered=Compare(S_e,S_f)=Equal ConditionSatisfied=Evaluate(Co)=TrueConditionSatisfied=Evaluate(Co)=True ValidEvidence=Validate(Ev)=TrueValidEvidence=Validate(Ev)=True

因此：

Repair Created
≠ Repair Executed
≠ Repair Completed
≠ Repair Effective
≠ Repair Verified

最终只认：

RepairState = Verified

作为修复已经通过验证的正式状态。

后续章节建议全部采用这一套定义，避免 Succeeded / Effective / Recovered / Verified 再同时作为Repair生命周期状态，从而保持 StateEngine → ProtectionEngine → DiagnosisEngine → RepairEngine → Verification 的状态体系一致。

206.1 修复条件逻辑的问题

上一版RepairEngine存在一个需要修正的工程问题。

原逻辑类似：

$validCapability = !empty($capability);
$validState = !empty($state);
$validRule = !empty($rule);

这种判断只能证明：

数据结构存在。

不能证明：

修复条件已经满足。

例如：

$capability = array(
    'replace_resource' => false
);

数组并不为空，但是实际上：

Replace Resource Capability = Unavailable

又例如：

$state = array(
    'value' => 'blocked'
);

State存在，但并不代表当前状态允许Repair。

因此必须将：

[
Existence
]

与：

[
Availability
]

以及：

[
ConditionSatisfied
]

严格区分。

---

206.2 正确的Repair执行条件

RepairEngine真正需要判断的是：

[
RepairExecutable=
A
\land
D
\land
C
\land
O
\land
Ca
\land
S
\land
Ru
]

其中：

• (A)：Abnormality，有效异常
• (D)：Diagnosis，有效诊断
• (C)：Cause，原因可处理
• (O)：Object，目标对象有效
• (Ca)：Capability，修复能力可用
• (S)：State，当前状态允许修复
• (Ru)：Rule，修复规则允许

因此：

[
\boxed{
RepairExecutable=
ValidAbnormality
\land
ValidDiagnosis
\land
RepairableCause
\land
ValidObject
\land
CapabilityAvailable
\land
StateAllowsRepair
\land
RuleAllowsRepair
}
]

---

206.3 修复条件不能混为一个条件

RepairEngine应该把修复条件拆成七个独立判断。

Abnormality
    ↓
Diagnosis
    ↓
Cause
    ↓
Object
    ↓
Capability
    ↓
State
    ↓
Rule
    ↓
RepairExecutable

分别计算：

[
A_v
]

[
D_v
]

[
C_v
]

[
O_v
]

[
Ca_v
]

[
S_v
]

[
Ru_v
]

最终：

[
RE_v=
A_v\land D_v\land C_v\land O_v
\land Ca_v\land S_v\land Ru_v
]

这样可以知道修复为什么不能执行，而不是只得到一个：

false

---

206.4 有效异常条件

有效异常不能简单判断：

!empty($abnormality)

正确模型：

[
ValidAbnormality=
Status\neq Normal
\land
Evidence
\land
Actual
]

因此至少检查：

status
actual
evidence

例如：

$abnormality = array(
    'status' => 'failure',
    'actual' => 'failed',
    'evidence' => true
);

才可以进入Repair。

如果：

$abnormality = array(
    'status' => 'unknown'
);

不能直接进入Repair。

应该：

Unknown
→ Diagnosis / Evidence Collection

---

206.5 有效诊断条件

Diagnosis不是简单“有数组”。

应该判断Diagnosis状态。

允许进入Repair的诊断状态例如：

cause_found
confirmed
multiple_candidates

而：

unknown
detected
analyzing

通常还不能直接Repair。

因此：

[
ValidDiagnosis=
DiagnosisExists
\land
DiagnosisState
\in
{CauseFound,Confirmed,MultipleCandidates}
]

如果原因仍然处于：

Analyzing

则：

DiagnosisEngine
→ Continue Diagnosis

而不是：

Diagnosis
→ Repair

---

206.6 原因可修复条件

即使Diagnosis存在，也不代表一定可以Repair。

例如：

Cause:
Unknown

则：

[
RepairableCause=False
]

又例如：

Cause:
Environment

但系统没有任何Environment Recovery能力，则：

[
RepairableCause=False
]

因此：

[
RepairableCause=
CauseExists
\land
CauseKnown
\land
RepairMethodExists
]

这里的Repair Method可以来自：

• 固定Repair Rule
• MethodEngine
• Knowledge
• Experience
• 已验证历史

但不能因为“存在一个Cause”，就假设一定存在Repair。

---

206.7 对象有效条件

Repair必须明确目标对象。

定义：

[
ValidObject=
ObjectExists
\land
ObjectNotDeleted
\land
ObjectRepairable
]

例如：

$object = array(
    'id' => 1001,
    'state' => 'blocked',
    'repairable' => true
);

如果：

$object['repairable'] = false;

则：

Repair Blocked
Reason = Object Not Repairable

---

206.8 修复能力条件

这是上一版最需要修正的部分。

不能：

!empty($capability)

而应该明确判断：

[
CapabilityAvailable=
Type
\land
Condition
\land
State
\land
Range
\land
Verification
]

例如Repair类型：

resource_replacement

要求：

Capability:
replace_resource = true

如果：

$capability['replace_resource'] = false;

则：

[
CapabilityAvailable=False
]

即使Capability数组存在，也不能执行。

---

206.9 修复能力的实际计算

定义：

protected function isCapabilityAvailable(
    $capability,
    $repairType
)

根据Repair Type检查具体Capability。

例如：

switch ($repairType) {
    case 'resource_replacement':
        return isset($capability['replace_resource'])
            && $capability['replace_resource'] === true;

    case 'state_recovery':
        return isset($capability['recover_state'])
            && $capability['recover_state'] === true;

    case 'method_change':
        return isset($capability['change_method'])
            && $capability['change_method'] === true;

    case 'action_replacement':
        return isset($capability['replace_action'])
            && $capability['replace_action'] === true;

    default:
        return false;
}

这样才是真正的：

[
CapabilityAvailable
]

---

206.10 State允许条件

State存在并不等于State允许Repair。

例如：

Ready
Running
Blocked
Failed
Recovering

不同State对应不同Repair权限。

可以定义：

protected function isStateRepairable($state)
{
    if (!isset($state['value'])) {
        return false;
    }

    $repairableStates = array(
        'failed',
        'blocked',
        'degraded',
        'abnormal',
        'inactive'
    );

    return in_array(
        $state['value'],
        $repairableStates
    );
}

这里的含义是：

当前状态属于允许进入Repair流程的状态。

但这仍然只是第一层判断。

真正的状态转换还必须交给StateEngine。

---

206.11 State允许Repair与StateTransition不同

必须区分：

[
StateAllowsRepair
]

与：

[
ValidStateTransition
]

例如：

Blocked
→ Repair

表示当前状态允许Repair。

但是Repair完成后：

Blocked
→ Ready

是否合法，则由：

StateEngine

判断。

因此：

RepairEngine
→ State Transition Candidate
→ StateEngine
→ Verified State Transition

RepairEngine不能直接：

$state['value'] = 'ready';

---

206.12 修复规则条件

Rule也不能简单：

!empty($rule)

应该计算：

[
RuleAllowsRepair=
RepairTypeAllowed
\land
ConditionSatisfied
\land
RetryPolicySatisfied
\land
SafetyConditionSatisfied
]

例如：

$rule = array(
    'repair_allowed' => true,
    'allowed_types' => array(
        'resource_replacement',
        'state_recovery'
    ),
    'max_retry' => 3,
    'safety_check' => true
);

如果：

$rule['repair_allowed'] = false;

则任何Repair Candidate都不能执行。

---

206.13 Retry条件修正

Retry不能简单作为普通Repair无限执行。

正确条件：

[
RetryAllowed=
RepairAllowed
\land
RetryCount<RetryLimit
\land
CauseStillRepairable
]

例如：

$retryCount = 2;
$retryLimit = 3;

则：

[
2<3
]

所以允许Retry。

如果：

$retryCount = 3;
$retryLimit = 3;

则：

[
3<3=False
]

因此：

Retry Blocked

必须转向：

New Diagnosis

或者：

Alternative Repair

---

206.14 修复候选的正确状态机

Repair Candidate应该经历：

Created
→ Validated
→ CapabilityChecked
→ StateChecked
→ RuleChecked
→ Executable

失败路径：

Created
→ Invalid

或者：

CapabilityChecked
→ Blocked

或者：

StateChecked
→ Blocked

或者：

RuleChecked
→ Rejected

只有：

Executable

才可以进入Decision。

---

206.15 Decision与Repair Candidate的边界

多个Repair Candidate存在时：

RepairEngine
→ Candidate 1
→ Candidate 2
→ Candidate 3

RepairEngine计算每个Candidate的：

• 合法性
• 能力
• 状态
• 条件
• 风险
• 成本
• 历史证据
• 验证情况

然后：

DecisionEngine

负责最终选择。

因此：

[
RepairEngine
\neq
DecisionEngine
]

RepairEngine：

哪些Repair可以执行？

DecisionEngine：

当前应该选择哪个Repair？

---

206.16 修复执行条件统一公式

最终统一为：

[
\boxed{
CanRepair=
A_v
\land
D_v
\land
C_v
\land
O_v
\land
Ca_v
\land
S_v
\land
Ru_v
}
]

其中：

符号	含义
(A_v)	Valid Abnormality，有效异常
(D_v)	Valid Diagnosis，有效诊断
(C_v)	Repairable Cause，可处理原因
(O_v)	Valid Object，有效对象
(Ca_v)	Capability Available，修复能力可用
(S_v)	State Allows Repair，当前状态允许修复
(Ru_v)	Rule Allows Repair，规则允许修复

这个公式比上一版：

[
D\land C\land Ca\land S\land Ru\land O
]

更加严格，因为现在每一个变量都表示已经经过实际条件计算的布尔结果，而不是“对象存在”。

---

206.17 修正后的完整PHP计算实现

下面将上述条件全部落实到RepairEngine中。

<?php

abstract class Engine
{
    public function calculate($input)
    {
        return array();
    }
}

class RepairEngine extends Engine
{
    public function calculate($input)
    {
        $abnormality = $this->getArray(
            $input,
            'abnormality'
        );

        $diagnosis = $this->getArray(
            $input,
            'diagnosis'
        );

        $cause = $this->getArray(
            $input,
            'cause'
        );

        $object = $this->getArray(
            $input,
            'object'
        );

        $state = $this->getArray(
            $input,
            'state'
        );

        $capability = $this->getArray(
            $input,
            'capability'
        );

        $rules = $this->getArray(
            $input,
            'rules'
        );

        $evidence = $this->getArray(
            $input,
            'evidence'
        );

        $time = isset($input['time'])
            ? $input['time']
            : time();

        /*
         * 第一阶段：计算异常是否有效
         */
        $abnormalityValid =
            $this->isValidAbnormality(
                $abnormality,
                $evidence
            );

        /*
         * 第二阶段：计算诊断是否有效
         */
        $diagnosisValid =
            $this->isValidDiagnosis(
                $diagnosis
            );

        /*
         * 第三阶段：计算原因是否可修复
         */
        $causeRepairable =
            $this->isRepairableCause(
                $cause
            );

        /*
         * 第四阶段：对象是否有效
         */
        $objectValid =
            $this->isValidObject(
                $object
            );

        /*
         * 没有原因时不能直接进入Repair
         */
        if (!$causeRepairable) {
            return $this->buildBlockedResult(
                'cause_not_repairable',
                $time
            );
        }

        /*
         * 根据Cause生成Repair Candidate
         */
        $candidates =
            $this->buildRepairCandidates(
                $cause,
                $object
            );

        $checkedCandidates = array();

        foreach ($candidates as $candidate) {

            $candidateType =
                $candidate['type'];

            /*
             * 能力判断
             */
            $capabilityAvailable =
                $this->isCapabilityAvailable(
                    $capability,
                    $candidateType
                );

            /*
             * 状态判断
             */
            $stateAllowsRepair =
                $this->isStateRepairable(
                    $state
                );

            /*
             * 规则判断
             */
            $ruleAllowsRepair =
                $this->isRuleAllowsRepair(
                    $rules,
                    $candidateType
                );

            /*
             * 最终可执行条件
             */
            $canRepair =
                $abnormalityValid &&
                $diagnosisValid &&
                $causeRepairable &&
                $objectValid &&
                $capabilityAvailable &&
                $stateAllowsRepair &&
                $ruleAllowsRepair;

            $candidate['conditions'] = array(
                'abnormality_valid' =>
                    $abnormalityValid,

                'diagnosis_valid' =>
                    $diagnosisValid,

                'cause_repairable' =>
                    $causeRepairable,

                'object_valid' =>
                    $objectValid,

                'capability_available' =>
                    $capabilityAvailable,

                'state_allows_repair' =>
                    $stateAllowsRepair,

                'rule_allows_repair' =>
                    $ruleAllowsRepair
            );

            $candidate['executable'] =
                $canRepair;

            $candidate['score'] =
                $this->calculateRepairScore(
                    $candidate,
                    $evidence
                );

            $checkedCandidates[] =
                $candidate;
        }

        usort(
            $checkedCandidates,
            array(
                $this,
                'compareCandidate'
            )
        );

        return array(
            'status' =>
                'repair_candidates_calculated',

            'repair_required' =>
                $abnormalityValid,

            'conditions' => array(
                'abnormality_valid' =>
                    $abnormalityValid,

                'diagnosis_valid' =>
                    $diagnosisValid,

                'cause_repairable' =>
                    $causeRepairable,

                'object_valid' =>
                    $objectValid
            ),

            'candidates' =>
                $checkedCandidates,

            'time' =>
                $time
        );
    }

    protected function getArray(
        $input,
        $key
    ) {
        if (
            !isset($input[$key]) ||
            !is_array($input[$key])
        ) {
            return array();
        }

        return $input[$key];
    }

    protected function isValidAbnormality(
        $abnormality,
        $evidence
    ) {
        if (empty($abnormality)) {
            return false;
        }

        if (
            !isset($abnormality['status']) ||
            $abnormality['status'] === 'normal' ||
            $abnormality['status'] === 'unknown'
        ) {
            return false;
        }

        if (
            !isset($abnormality['actual'])
        ) {
            return false;
        }

        if (empty($evidence)) {
            return false;
        }

        return true;
    }

    protected function isValidDiagnosis(
        $diagnosis
    ) {
        if (empty($diagnosis)) {
            return false;
        }

        if (
            !isset($diagnosis['state'])
        ) {
            return false;
        }

        $validStates = array(
            'cause_found',
            'confirmed',
            'multiple_candidates'
        );

        return in_array(
            $diagnosis['state'],
            $validStates
        );
    }

    protected function isRepairableCause(
        $cause
    ) {
        if (empty($cause)) {
            return false;
        }

        if (
            !isset($cause['type']) ||
            $cause['type'] === ''
        ) {
            return false;
        }

        $nonRepairable = array(
            'unknown',
            'unrecoverable',
            'no_cause'
        );

        if (
            in_array(
                strtolower($cause['type']),
                $nonRepairable
            )
        ) {
            return false;
        }

        return true;
    }

    protected function isValidObject(
        $object
    ) {
        if (empty($object)) {
            return false;
        }

        if (
            !isset($object['id']) ||
            $object['id'] === ''
        ) {
            return false;
        }

        if (
            isset($object['repairable']) &&
            $object['repairable'] === false
        ) {
            return false;
        }

        return true;
    }

    protected function isCapabilityAvailable(
        $capability,
        $repairType
    ) {
        if (empty($capability)) {
            return false;
        }

        switch ($repairType) {

            case 'resource_replacement':
                return isset(
                    $capability['replace_resource']
                ) &&
                $capability['replace_resource']
                    === true;

            case 'state_recovery':
                return isset(
                    $capability['recover_state']
                ) &&
                $capability['recover_state']
                    === true;

            case 'method_change':
                return isset(
                    $capability['change_method']
                ) &&
                $capability['change_method']
                    === true;

            case 'action_replacement':
                return isset(
                    $capability['replace_action']
                ) &&
                $capability['replace_action']
                    === true;

            case 'environment_recovery':
                return isset(
                    $capability['recover_environment']
                ) &&
                $capability[
                    'recover_environment'
                ] === true;

            case 'retry':
                return isset(
                    $capability['retry']
                ) &&
                $capability['retry'] === true;

            case 'recalculate':
                return isset(
                    $capability['recalculate']
                ) &&
                $capability['recalculate']
                    === true;
        }

        return false;
    }

    protected function isStateRepairable(
        $state
    ) {
        if (
            empty($state) ||
            !isset($state['value'])
        ) {
            return false;
        }

        $repairableStates = array(
            'failed',
            'blocked',
            'degraded',
            'abnormal',
            'inactive'
        );

        return in_array(
            $state['value'],
            $repairableStates
        );
    }

    protected function isRuleAllowsRepair(
        $rules,
        $repairType
    ) {
        if (empty($rules)) {
            return false;
        }

        if (
            !isset($rules['repair_allowed']) ||
            $rules['repair_allowed'] !== true
        ) {
            return false;
        }

        if (
            isset($rules['allowed_types']) &&
            is_array($rules['allowed_types'])
        ) {
            if (
                !in_array(
                    $repairType,
                    $rules['allowed_types']
                )
            ) {
                return false;
            }
        }

        return true;
    }

    protected function buildRepairCandidates(
        $cause,
        $object
    ) {
        $type = strtolower(
            $cause['type']
        );

        $objectId = $object['id'];

        $candidates = array();

        switch ($type) {

            case 'resource':

                $candidates[] = array(
                    'type' =>
                        'resource_replacement',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );

                break;

            case 'state':

                $candidates[] = array(
                    'type' =>
                        'state_recovery',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );

                break;

            case 'method':

                $candidates[] = array(
                    'type' =>
                        'method_change',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );

                break;

            case 'action':

                $candidates[] = array(
                    'type' =>
                        'action_replacement',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );

                break;

            case 'environment':

                $candidates[] = array(
                    'type' =>
                        'environment_recovery',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );

                break;

            default:

                $candidates[] = array(
                    'type' =>
                        'retry',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );

                $candidates[] = array(
                    'type' =>
                        'recalculate',

                    'object_id' =>
                        $objectId,

                    'state' =>
                        'candidate'
                );
        }

        return $candidates;
    }

    protected function calculateRepairScore(
        $candidate,
        $evidence
    ) {
        $score = 0;

        if (
            $candidate['executable']
        ) {
            $score += 50;
        }

        if (!empty($evidence)) {
            $score += 20;
        }

        switch ($candidate['type']) {

            case 'state_recovery':
                $score += 15;
                break;

            case 'resource_replacement':
                $score += 14;
                break;

            case 'action_replacement':
                $score += 12;
                break;

            case 'method_change':
                $score += 10;
                break;

            case 'environment_recovery':
                $score += 9;
                break;

            case 'retry':
                $score += 5;
                break;
        }

        return $score;
    }

    public function calculateRepairResult(
        $repair,
        $action,
        $execution,
        $expectedResult,
        $actualResult,
        $beforeState,
        $afterState,
        $expectedState,
        $evidence
    ) {
        $resultMatch =
            $this->compareValue(
                $expectedResult,
                $actualResult
            );

        $stateRecovered =
            $this->compareValue(
                $expectedState,
                $afterState
            );

        $effective =
            $resultMatch &&
            $stateRecovered;

        $verified =
            $effective &&
            !empty($evidence);

        if ($verified) {
            $status = 'verified';
        } elseif ($effective) {
            $status = 'effective_unverified';
        } elseif (
            $resultMatch ||
            $stateRecovered
        ) {
            $status = 'partially_recovered';
        } else {
            $status = 'failed';
        }

        return array(
            'repair' =>
                $repair,

            'action' =>
                $action,

            'execution' =>
                $execution,

            'expected_result' =>
                $expectedResult,

            'actual_result' =>
                $actualResult,

            'before_state' =>
                $beforeState,

            'after_state' =>
                $afterState,

            'expected_state' =>
                $expectedState,

            'result_match' =>
                $resultMatch,

            'state_recovered' =>
                $stateRecovered,

            'effective' =>
                $effective,

            'verified' =>
                $verified,

            'status' =>
                $status,

            'evidence' =>
                $evidence
        );
    }

    protected function compareValue(
        $expected,
        $actual
    ) {
        if (
            is_array($expected) &&
            is_array($actual)
        ) {
            return $expected == $actual;
        }

        return $expected === $actual;
    }

    protected function buildBlockedResult(
        $reason,
        $time
    ) {
        return array(
            'status' =>
                'repair_blocked',

            'repair_required' =>
                true,

            'reason' =>
                $reason,

            'candidates' =>
                array(),

            'time' =>
                $time
        );
    }

    public function compareCandidate(
        $a,
        $b
    ) {
        if (
            $a['score'] ==
            $b['score']
        ) {
            return 0;
        }

        return (
            $a['score'] >
            $b['score']
        ) ? -1 : 1;
    }
}

---

206.18 修正后的执行逻辑

新的代码不再是：

字段存在
→ 可以Repair

而是：

Abnormality有效
        ↓
Diagnosis有效
        ↓
Cause可修复
        ↓
Object有效
        ↓
生成Repair Candidate
        ↓
检查Capability
        ↓
检查State
        ↓
检查Rule
        ↓
CanRepair
        ↓
进入Decision

其中最关键的判断：

$canRepair =
    $abnormalityValid &&
    $diagnosisValid &&
    $causeRepairable &&
    $objectValid &&
    $capabilityAvailable &&
    $stateAllowsRepair &&
    $ruleAllowsRepair;

这才对应理论公式：

[
\boxed{
CanRepair=
A_v\land D_v\land C_v\land O_v
\land Ca_v\land S_v\land Ru_v
}
]

---

206.19 修复结果逻辑也必须修正

上一版的另一个潜在问题是：

$effective =
    $resultMatch &&
    $stateRecovered;

这个方向是正确的，但必须明确：

resultMatch和stateRecovered比较的是结构化实际结果，而不是简单判断Execution是否Completed。

因此：

Execution Completed

只能说明：

[
ExecutionState=Completed
]

不能说明：

[
RepairEffective=True
]

正确过程：

[
ExecutionCompleted
\rightarrow
ActualResult
\rightarrow
ResultComparison
\rightarrow
StateComparison
\rightarrow
Verification
]

---

206.20 最终修复判断

最终定义：

[
RepairExecuted=
E_x.state=Completed
]

[
RepairEffective=
Compare(R_e,R)
\land
Compare(S_e,S_f)
]

其中：

• (E_x)：实际Execution
• (R_e)：Expected Result
• (R)：Actual Result
• (S_e)：Expected State
• (S_f)：Final State

最后：

[
RepairVerified=
RepairEffective
\land
ConditionSatisfied
\land
Ev
]

因此：

[
\boxed{
RepairExecuted
\neq
RepairEffective
\neq
RepairVerified
}
]

---

206.21 修复失败后的正确分流

如果：

RepairExecuted = false

说明执行没有完成：

Repair
→ Execution Failure
→ Feedback
→ Diagnosis

如果：

RepairExecuted = true
RepairEffective = false

说明动作执行了，但没有恢复：

Repair
→ Actual Result
→ State Not Recovered
→ Diagnosis Re-evaluation

如果：

RepairEffective = true
RepairVerified = false

说明结果和状态看起来已经恢复，但是证据不足：

Repair
→ Effective
→ Verification Pending

只有：

RepairVerified = true

才进入：

Recovered

---

206.22 修正后的RepairEngine完整边界

最终RepairEngine不应该直接负责：

Diagnosis原因分析
Decision最终选择
Action底层执行
Execution实际运行
State直接修改
Database直接保存
Learning直接修改知识

而负责：

异常是否需要修复
        ↓
原因是否可修复
        ↓
生成修复候选
        ↓
检查修复条件
        ↓
计算修复可执行性
        ↓
计算修复结果
        ↓
计算修复验证结果

因此：

[
\boxed{
RepairEngine=
RepairCalculation+
RepairCondition+
RepairResult+
RepairVerification
}
]

---

206.23 修正后的完整闭环

最终统一为：

[
Execution
\rightarrow
Result
\rightarrow
Feedback
\rightarrow
Abnormality
\rightarrow
Diagnosis
]

然后：

[
Diagnosis
\rightarrow
Cause
\rightarrow
RepairCandidate
\rightarrow
CapabilityCheck
\rightarrow
StateCheck
\rightarrow
RuleCheck
]

之后：

[
RepairCandidate
\rightarrow
Decision
\rightarrow
RepairAction
\rightarrow
ActionEngine
\rightarrow
ExecutionEngine
]

最后：

[
ActualResult
\rightarrow
Feedback
\rightarrow
StateEngine
\rightarrow
RepairVerification
]

形成：

[
\boxed{
Abnormality
\rightarrow
Diagnosis
\rightarrow
RepairCondition
\rightarrow
Repair
\rightarrow
Execution
\rightarrow
Result
\rightarrow
StateRecovery
\rightarrow
Verification
}
]

这比上一版更严格，因为Repair不再根据“数据是否存在”判断，而是根据“条件是否实际满足”判断。