Agent上下文治理：流程驱动架构中的深度设计

{
  "activityId": "risk_assessment",
  "preserveKeys": [
    "risk_level",        // 风险等级 — 后续审批依赖
    "assessment_id",     // 评估ID — 审计追踪
    "risk_factors"       // 风险因子 — 决策解释
  ]
}

{
  "compressRules": [
    {
      "pattern": "tool_call_result",
      "action": "extract_keys",
      "extractKeys": ["status", "data.id", "data.summary"]
    },
    {
      "pattern": "reasoning_chain",
      "action": "summarize",
      "maxTokens": 100
    },
    {
      "pattern": "error_retry_log",
      "action": "count_only",
      "keepLast": 1
    }
  ]
}

你是一个上下文压缩决策引擎。当前上下文状态：
- HISTORY层: {token_count} tokens, {key_count} keys
- WORKING层: {token_count} tokens, {key_count} keys
- 注意力评分: 密度={density}, 冗余={redundancy}

必须保留的key: {preserve_keys}
当前活动需要的上下文: {required_context}

请决定：
1. 哪些已完成活动的上下文可以压缩为摘要？
2. 摘要应保留哪些关键信息点？
3. 哪些上下文可以完全移除？

输出JSON格式的压缩计划。

// Designer定义的分支条件（自然语言）
{
  "gatewayId": "approval_split",
  "type": "XOR_SPLIT",
  "branches": [
    {
      "id": "fast_track",
      "condition": "如果风险等级为低且金额小于5万，走快速通道",
      "contextInject": { "track_type": "fast", "requires_approval": false }
    },
    {
      "id": "full_review",
      "condition": "其他情况走完整审核流程",
      "contextInject": { "track_type": "full", "requires_approval": true }
    }
  ]
}

function detectConflicts(base, branches):
    conflicts = []
    allKeys = union(branches.map(b => b.keys()))
    
    for key in allKeys:
        baseValue = base.get(key)
        branchValues = branches.map(b => b.get(key))
        uniqueValues = distinct(branchValues.filter(v => v != baseValue))
        
        if uniqueValues.length > 1:
            // 多个分支对同一key写入了不同值 → 冲突
            conflicts.append({
                key: key,
                baseValue: baseValue,
                conflictingValues: uniqueValues,
                sourceBranches: branches.filter(b => b.get(key) in uniqueValues)
            })
        else if uniqueValues.length == 1 and baseValue != uniqueValues[0]:
            // 仅一个分支修改，且与基准不同 → 无冲突，采用修改值
            markAsModified(key, uniqueValues[0])
    
    return conflicts

{
  "_mergedConflicts": [
    {
      "key": "approval_status",
      "baseValue": "pending",
      "conflictingValues": ["approved", "rejected"],
      "sourceBranches": ["branch_finance", "branch_risk"],
      "resolution": null  // 待解决
    }
  ]
}

你是一个上下文合并冲突解决引擎。以下是合并冲突：

冲突Key: approval_status
- 基准值: pending
- 分支finance的值: approved (原因: 财务审核通过，金额在授权范围内)
- 分支risk的值: rejected (原因: 风险评估发现异常交易模式)

相关上下文:
- 金额: 120,000
- 风险等级: high
- 公司政策: 高风险+高金额需要双重审批

请决定：
1. 最终值应该是什么？
2. 决策依据是什么？
3. 是否需要升级为HUMAN确认？

输出JSON格式的冲突解决结果。

{
  "_splitSnapshot": {
    "snapshotId": "snap_20260708_001",
    "splitGatewayId": "parallel_review",
    "timestamp": "2026-07-08T10:30:00Z",
    "context": {
      "L0": "<reference>",
      "L1": "<reference>",
      "L2": { /* 深拷贝 */ },
      "L3": { /* 深拷贝 */ },
      "L4": { /* 深拷贝 */ }
    },
    "branchIds": ["branch_finance", "branch_risk", "branch_compliance"]
  }
}

// ActivityExtensionConfig 示例
{
  "activityId": "risk_assessment",
  "contextStrategy": {
    "preserveKeys": ["risk_level", "assessment_id"],
    "compressRules": [
      { "pattern": "tool_call_result", "action": "extract_keys" }
    ],
    "compressTokenThreshold": 4000,
    "attentionThresholds": {
      "density": 0.15, "redundancy": 0.3
    }
  },
  "mergeStrategy": "MERGE_WITH_CONFLICT_DETECT",
  "knowledgeConfig": {
    "ragCollections": ["risk_kb", "policy_kb"],
    "confidenceThreshold": 0.7
  }
}

// REST端点
POST /api/context-governance/inspect    // 查看上下文状态
POST /api/context-governance/compress   // 手动触发压缩
POST /api/context-governance/inject     // 注入上下文
POST /api/context-governance/resolve    // 冲突仲裁
POST /api/context-governance/rollback   // 回退到快照
POST /api/context-governance/config     // 运行时修改配置

context_inspect({
  layers: ["L3", "L4"],          // 检查HISTORY和WORKING层
  metrics: [                       // 请求的统计指标
    "token_count",                 // 每层token数
    "key_count",                   // 每层key数
    "attention_score",             // 注意力评分(5维)
    "last_modified",               // 最后修改时间
    "size_bytes"                   // 内存占用
  ],
  filter: {                        // 可选过滤条件
    "key_prefix": "risk_*",       // 只检查risk开头的key
    "modified_after": "2026-07-08T10:00:00Z"
  }
})

// 返回
{
  "L3": {
    "token_count": 3200,
    "key_count": 18,
    "attention_score": { "density": 0.12, "redundancy": 0.35 },
    "keys": ["risk_level", "assessment_id", ...]
  },
  "L4": {
    "token_count": 800,
    "key_count": 6,
    "attention_score": { "density": 0.45, "redundancy": 0.1 }
  }
}

// 执行压缩
context_compress({
  action: "compress",
  target_layers: ["L3"],
  preserve_keys: ["risk_level", "assessment_id", "risk_factors"],
  compress_rules: [
    { pattern: "tool_call_result", action: "extract_keys", extractKeys: ["status", "summary"] },
    { pattern: "reasoning_chain", action: "summarize", maxTokens: 100 }
  ],
  max_tokens: 2000
})

// 评估压缩效果
context_compress({
  action: "evaluate",
  before_snapshot_id: "snap_before_compress"
})

// 解压（回退压缩）
context_compress({
  action: "decompress",
  snapshot_id: "snap_before_compress"
})

// 分支评估
context_branch({
  action: "evaluate",
  branch_id: "branch_finance",
  required_keys: ["amount", "approval_status"]
})

// 冲突解决
context_branch({
  action: "resolve_conflict",
  conflict_key: "approval_status",
  resolution: "approved",
  reason: "财务审核通过优先，风险问题后续处理"
})

// 创建快照
context_branch({
  action: "snapshot",
  layers: ["L2", "L3", "L4"]
})

human_confirm({
  type: "conflict_resolution",
  message: "分支finance和risk对approval_status存在冲突，请选择最终值",
  options: [
    { label: "采用approved（财务审核通过）", value: "approved" },
    { label: "采用rejected（风险评估拒绝）", value: "rejected" },
    { label: "升级为双人审批", value: "escalate" }
  ],
  timeout: 300  // 5分钟超时
})

┌─ LLM调用序列：压缩决策 ─────────────────────────────┐
│                                                       │
│ 1. context_inspect(layers=["L3","L4"],                │
│    metrics=["token_count","attention_score"])          │
│    → L3: 3200 tokens, density=0.12                    │
│    → L4: 800 tokens, density=0.45                     │
│                                                       │
│ 2. [LLM判断] L3密度<0.15 → 触发压缩                    │
│                                                       │
│ 3. context_compress(action="compress",                 │
│    target_layers=["L3"],                              │
│    preserve_keys=["risk_level","assessment_id"],       │
│    max_tokens=1500)                                   │
│    → 压缩完成: 3200→1350 tokens                        │
│                                                       │
│ 4. context_compress(action="evaluate",                 │
│    before_snapshot_id="snap_xxx")                     │
│    → 密度提升: 0.12→0.38, 关键key全部保留               │
│                                                       │
│ 5. [LLM判断] 压缩效果良好，无需human_confirm            │
│                                                       │
└───────────────────────────────────────────────────────┘

class ContextGovernanceDTO {
  // 层大小信息
  Map<String, LayerInfo> layerInfos;     // L0~L5各层统计
  
  // 压缩状态
  CompressStatus compressStatus;           // 压缩状态/历史/阈值
  
  // 注意力评分
  AttentionScore attentionScore;           // 5维注意力评分
  
  // 知识评分
  List<KnowledgeScore> knowledgeScores;   // 知识置信度列表
  
  // 冲突信息
  List<MergedConflict> mergedConflicts;   // 待解决冲突
  
  // 分支信息
  List<BranchInfo> branchInfos;           // 各分支状态
  
  // 配置快照
  ActivityExtensionConfig activeConfig;    // 当前生效的配置
}

class LayerInfo {
  String layerId;                          // L0~L5
  int tokenCount;
  int keyCount;
  long sizeBytes;
  long lastModified;
  List<String> topKeys;                    // 占比最高的key
}

class LayeredContext {
    // 六层存储，每层是一个Map
    private Map<ContextLayer, Map<String, Object>> layers;
    
    // 读取：按优先级从L0到L5逐层查找
    Object resolveKey(String key) {
        for (ContextLayer layer : ContextLayer.values()) {
            Map<String, Object> layerData = layers.get(layer);
            if (layerData.containsKey(key)) {
                return layerData.get(key);
            }
        }
        return null; // key不存在
    }
    
    // 写入：指定层级 + 权限校验 + 自动升级
    void write(ContextLayer targetLayer, String key, Object value) {
        // 1. 权限校验
        if (targetLayer == SYSTEM) throw new ContextWriteDeniedException();
        if (targetLayer == PROCESS && layers.get(PROCESS).containsKey(key))
            throw new ContextWriteDeniedException("PROCESS层仅允许追加");
        
        // 2. 自动升级：如果更底层已有该key，升级到那个层
        ContextLayer actualLayer = findExistingLayer(key);
        if (actualLayer != null && actualLayer.ordinal() < targetLayer.ordinal())
            targetLayer = actualLayer;
        
        // 3. 写入
        layers.get(targetLayer).put(key, value);
    }
}

class CompressTriggerDetector {
    boolean detect(LayeredContext context, ActivityExtensionConfig config) {
        // 阈值检测
        int totalTokens = context.getTokenCount(L3) + context.getTokenCount(L4);
        if (totalTokens > config.getCompressTokenThreshold()) return true;
        
        int msgCount = context.getMessageCount(L3);
        if (msgCount > config.getCompressMessageThreshold()) return true;
        
        // 注意力5维检测
        AttentionScore score = calculateAttentionScore(context);
        if (score.getDensity() < 0.15) return true;     // 关键信息密度过低
        if (score.getRedundancy() > 0.3) return true;    // 冗余度过高
        if (score.getDecay() < 0.6) return true;        // 时序衰减严重
        if (score.getConflict() > 0.05) return true;     // 语义冲突
        if (score.getToolEfficiency() < 0.5) return true; // 工具调用效率低
        
        return false;
    }
    
    AttentionScore calculateAttentionScore(LayeredContext context) {
        // 1. 密度：preserveKeys对应token / 总token
        double density = calculateDensity(context);
        // 2. 冗余：相似消息对数 / 总消息对数
        double redundancy = calculateRedundancy(context);
        // 3. 衰减：最近N轮注意力权重 / 总权重
        double decay = calculateTemporalDecay(context);
        // 4. 冲突：矛盾key数 / 总key数
        double conflict = calculateSemanticConflict(context);
        // 5. 工具效率：有效工具返回 / 总工具调用
        double toolEff = calculateToolEfficiency(context);
        
        return new AttentionScore(density, redundancy, decay, conflict, toolEff);
    }
}

class ContextSplitter {
    List<LayeredContext> split(LayeredContext source, SplitGateway gateway) {
        // 保存快照（合并时的基准）
        ContextSnapshot snapshot = snapshotManager.saveSnapshot(source);
        
        List<LayeredContext> branches = new ArrayList<>();
        for (BranchDefinition branch : gateway.getBranches()) {
            LayeredContext branchContext = new LayeredContext();
            
            // L0/L1: 共享（引用传递）
            branchContext.setLayer(SYSTEM, source.getLayer(SYSTEM));
            branchContext.setLayer(PROCESS, source.getLayer(PROCESS));
            
            // L2: 继承（深拷贝基线 + 增量独立）
            Map<String, Object> knowledgeCopy = deepCopy(source.getLayer(KNOWLEDGE));
            branchContext.setLayer(KNOWLEDGE, knowledgeCopy);
            
            // L3: 独立（深拷贝，各自累积）
            Map<String, Object> historyCopy = deepCopy(source.getLayer(HISTORY));
            branchContext.setLayer(HISTORY, historyCopy);
            
            // L4: 深拷贝 + 分支条件注入
            Map<String, Object> workingCopy = deepCopy(source.getLayer(WORKING));
            branchContext.setLayer(WORKING, workingCopy);
            // 注入分支条件变量
            branch.getContextInject().forEach((k, v) -> 
                branchContext.write(WORKING, k, v));
            branchContext.write(WORKING, "_branch_id", branch.getId());
            branchContext.write(WORKING, "_snapshot_id", snapshot.getId());
            
            // L5: 清空（不传递）
            branchContext.setLayer(EPHEMERAL, new HashMap<>());
            
            branches.add(branchContext);
        }
        return branches;
    }
}

class ConflictDetector {
    List<MergedConflict> detectConflicts(
            Map<String, Object> base,
            List<Map<String, Object>> branches) {
        
        List<MergedConflict> conflicts = new ArrayList<>();
        
        // 收集所有key
        Set<String> allKeys = new HashSet<>();
        branches.forEach(b -> allKeys.addAll(b.keySet()));
        
        for (String key : allKeys) {
            Object baseValue = base.get(key);
            
            // 收集各分支的值（排除与base相同的）
            Set<Object> uniqueModifiedValues = new HashSet<>();
            List<String> modifyingBranches = new ArrayList<>();
            
            for (int i = 0; i < branches.size(); i++) {
                Object branchValue = branches.get(i).get(key);
                if (branchValue != null && !branchValue.equals(baseValue)) {
                    uniqueModifiedValues.add(branchValue);
                    modifyingBranches.add("branch_" + i);
                }
            }
            
            if (uniqueModifiedValues.size() > 1) {
                // 多个分支对同一key写入了不同值 → 冲突
                conflicts.add(new MergedConflict(
                    key, baseValue, 
                    new ArrayList<>(uniqueModifiedValues),
                    modifyingBranches
                ));
            }
        }
        return conflicts;
    }
}

class RuleDrivenCompressor {
    CompressResult compress(LayeredContext context, ActivityExtensionConfig config) {
        CompressResult result = new CompressResult();
        Map<String, Object> history = context.getLayer(HISTORY);
        
        // 1. 提取PRESERVE_KEYS（无条件保留）
        Map<String, Object> preserved = new HashMap<>();
        for (String key : config.getPreserveKeys()) {
            if (history.containsKey(key)) {
                preserved.put(key, history.get(key));
            }
        }
        
        // 2. 应用COMPRESS_BLOCKS规则
        Map<String, Object> compressed = new HashMap<>(preserved);
        for (CompressRule rule : config.getCompressRules()) {
            List<Map.Entry<String, Object>> matched = findMatches(history, rule.getPattern());
            for (Map.Entry<String, Object> entry : matched) {
                switch (rule.getAction()) {
                    case "extract_keys":
                        Map<String, Object> extracted = extractKeys(entry.getValue(), rule.getExtractKeys());
                        compressed.put(entry.getKey(), extracted);
                        break;
                    case "summarize":
                        String summary = summarize(entry.getValue(), rule.getMaxTokens());
                        compressed.put(entry.getKey() + "_summary", summary);
                        break;
                    case "count_only":
                        compressed.put(entry.getKey() + "_count", matched.size());
                        if (rule.getKeepLast() > 0) {
                            compressed.put(entry.getKey() + "_last", 
                                matched.get(matched.size() - 1).getValue());
                        }
                        break;
                }
            }
        }
        
        // 3. 替换HISTORY层
        int beforeTokens = context.getTokenCount(HISTORY);
        context.setLayer(HISTORY, compressed);
        int afterTokens = context.getTokenCount(HISTORY);
        
        result.setBeforeTokens(beforeTokens);
        result.setAfterTokens(afterTokens);
        result.setCompressionRatio(1.0 - (double)afterTokens / beforeTokens);
        return result;
    }
}

流程: 提交申请 → 风险评估 → [XOR_SPLIT] → 快速通道 / 完整审核 → [AND_JOIN] → 放款决策

═══ 活动1: 提交申请 ═══
L4 WORKING: {amount: 50000, applicant_id: "APP001", purpose: "经营贷"}
L3 HISTORY: [] (流程刚开始)
→ 活动完成，WORKING→HISTORY迁移
L3 HISTORY: [{activity: "submit", summary: "申请50万经营贷", keys: {amount, applicant_id}}]

═══ 活动2: 风险评估 ═══
L4 WORKING: {amount: 50000, applicant_id: "APP001"} (从HISTORY恢复的关键key)
L2 KNOWLEDGE: {风险评估规则, 行业黑名单} (RAG检索)
→ LLM调用: 结合WORKING和KNOWLEDGE进行风险评估
L4 WORKING: {risk_level: "medium", risk_factors: ["新客户", "跨行业"], assessment_id: "RA001"}
→ 活动完成，WORKING→HISTORY迁移
L3 HISTORY: [{submit...}, {activity: "risk_assess", summary: "风险中等", keys: {risk_level, assessment_id}}]

═══ D2: XOR_SPLIT 分裂决策 ═══
条件: risk_level == "low" AND amount < 50000 → 快速通道
当前: risk_level = "medium" → 走完整审核
→ 分裂时:
  - 保存快照 snap_001
  - WORKING深拷贝 + 注入 {track_type: "full", requires_approval: true}

═══ 活动3: 完整审核（包含并行分支） ═══
[XOR_SPLIT] → 财务审核 + 风险复核 (PARALLEL_SPLIT)
→ 分支A(财务): WORKING = 拷贝 + {review_type: "finance"}
→ 分支B(风险): WORKING = 拷贝 + {review_type: "risk"}

═══ D3: AND_JOIN 合并决策 ═══
分支A结果: {approval_status: "approved", finance_comment: "收入稳定"}
分支B结果: {approval_status: "rejected", risk_comment: "异常交易模式"}
→ 冲突检测: approval_status冲突 (approved vs rejected)
→ 策略: MERGE_WITH_CONFLICT_DETECT
→ LLM冲突解决: 结合risk_level=medium, 公司政策 → 升级为双人审批
→ human_confirm: 用户确认 → 最终值: "pending_dual_approval"

═══ 活动4: 放款决策 ═══
L3 HISTORY: [所有前置活动的摘要, 包括冲突解决记录]
L4 WORKING: {approval_status: "pending_dual_approval", ...}
→ 压缩检测: HISTORY层token > 阈值 → 触发压缩
→ 压缩后: HISTORY保留关键决策链，token从5000降至1800