┌─────────────────────────────────────────────────────────────┐
│                    应用交互层 (API Gateway)                    │
│  会议助手插件  │  知识检索门户  │  决策溯源看板  │  OpenAPI    │
├─────────────────────────────────────────────────────────────┤
│                    业务编排层 (Orchestration)                  │
│  版本发布流程  │  冲突仲裁工作流  │  变更影响分析  │  审计合规   │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────────────┐  ┌──────────────────┐                  │
│  │  增量图谱融合引擎 │  │  语义冲突消解引擎 │  ← 核心双引擎     │
│  └──────────────────┘  └──────────────────┘                  │
├─────────────────────────────────────────────────────────────┤
│                    存储持久层 (Multi-Model Storage)            │
│  图数据库(NebulaGraph)  │  向量库(Milvus)  │  对象存储(MinIO)  │
└─────────────────────────────────────────────────────────────┘

# 伪代码：基于 HNSW 向量索引 + 规则过滤的候选集生成
def candidate_recall(new_entity: Entity, top_k: int = 50) -> List[Entity]:
    # 1. 向量近邻检索（标题/别名/描述 Embedding）
    vec_candidates = vector_index.search(new_entity.embedding, top_k * 3)
    
    # 2. 规则硬过滤：同类型、同租户、时间窗口
    filtered = [e for e in vec_candidates 
                if e.type == new_entity.type 
                and e.tenant_id == new_entity.tenant_id
                and abs(e.updated_at - new_entity.created_at) < TIME_WINDOW]
    
    # 3. 轻量级特征打分（编辑距离、共现频次、属性重叠度）
    scored = [(e, lightweight_score(new_entity, e)) for e in filtered]
    return [e for e, s in sorted(scored, key=lambda x: -x[1])[:top_k]]

rule "互斥关系冲突预检"
when
    $r1: Relation(type == "subProjectOf", source == $p1, target == $p2)
    $r2: Relation(type == "competeWith", source == $p1, target == $p2)
then
    conflictDetector.markConflict($r1, $r2, ConflictType.MUTEX_RELATION);
end

rule "属性值域漂移预警"
when
    $e: Entity(version > 1)
    $prev: EntityVersion(entityId == $e.id, version == $e.version - 1)
    eval( !domainValidator.validate($e.getAttribute("metric_definition"), 
                                    $prev.getAttribute("metric_definition")) )
then
    conflictDetector.markConflict($e, $prev, ConflictType.SEMANTIC_DRIFT);
end

sequenceDiagram
    participant Client
    participant FusionEngine
    participant GraphDB
    participant EventStore
    Client->>FusionEngine: 提交融合请求(ΔG, expected_version)
    FusionEngine->>GraphDB: CAS 比对版本号
    alt 版本匹配
        GraphDB-->>FusionEngine: 成功
        FusionEngine->>EventStore: 追加 VersionEvent(MERGE, ΔG, lineage)
        FusionEngine->>GraphDB: 写入新版本顶点/边 + lineage 边
        FusionEngine-->>Client: 返回新版本号
    else 版本冲突
        FusionEngine-->>Client: 409 Conflict + 当前最新快照
    end

(:Entity {id, name, current_version})
  -[:HAS_VERSION {version, timestamp, operator, change_type}]-> 
(:EntityVersion {id, snapshot_json, vector_embedding})
  -[:DERIVED_FROM {merge_strategy, confidence}]-> 
(:EntityVersion)  // 形成有向无环图(DAG)

def generate_resolution_candidates(conflict: SemanticConflict) -> List[Resolution]:
    candidates = []
    
    # 策略 A：保留高可信度来源，标记低可信度为「待确认」
    high_trust = max(conflict.sources, key=lambda s: s.trust_score)
    candidates.append(Resolution(
        strategy="TRUST_WEIGHTED",
        action=f"采纳 {high_trust.source_id} 版本，其余标记 DEPRECATED",
        confidence=high_trust.trust_score,
        impact_analysis=estimate_impact(high_trust.version)
    ))
    
    # 策略 B：语义融合生成新定义（LLC - LLM-based Logical Composition）
    if conflict.type == ConflictType.DEFINITION_DRIFT:
        merged_def = llm_semantic_merge(
            [s.definition for s in conflict.sources],
            constraint=conflict.domain_ontology.constraints
        )
        candidates.append(Resolution(
            strategy="SEMANTIC_MERGE",
            action=f"生成融合定义: {merged_def}",
            confidence=merged_def.coherence_score,
            impact_analysis=estimate_impact(merged_def)
        ))
    
    # 策略 C：显式分叉，维护多版本共存（适用于口径分歧）
    if conflict.type == ConflictType.CALIBER_DIVERGENCE:
        candidates.append(Resolution(
            strategy="EXPLICIT_FORK",
            action="创建指标变体: GMV_FINANCE / GMV_OPS，建立映射关系",
            confidence=0.95,
            impact_analysis="零破坏性变更，需更新下游引用"
        ))
    
    return sorted(candidates, key=lambda c: -c.confidence)

// 查询 2024-03-15 当时「GMV」指标的定义及其下游依赖
MATCH (m:Metric {name: "GMV"})-[:HAS_VERSION]->(v:MetricVersion)
WHERE v.valid_from <= date("2024-03-15") < v.valid_to
OPTIONAL MATCH (v)<-[:DEPENDS_ON*]-(downstream:Report)
RETURN v.definition, v.calculation_logic, collect(downstream.name) AS impacted_reports

def compute_impact_radius(changed_entity_version: EntityVersion, max_hops: int = 3) -> ImpactReport:
    # 1. 反向遍历 DERIVED_FROM / DEPENDS_ON 边
    affected = graph_db.bfs_reverse(
        start=changed_entity_version,
        edge_types=["DERIVED_FROM", "DEPENDS_ON", "REFERENCES"],
        max_depth=max_hops
    )
    
    # 2. 分类汇总
    report = ImpactReport(
        direct_dependents=[n for n in affected if n.distance == 1],
        transitive_dependents=[n for n in affected if n.distance > 1],
        critical_path=identify_critical_path(affected),  # 基于业务重要权重
        breaking_change_risk=assess_breaking_risk(changed_entity_version, affected)
    )
    return report

graph TD
    A[原始多模态流] --> B{模态分流}
    B --> C[ASR + 说话人分离]
    B --> D[关键帧抽取 + OCR/图表识别]
    B --> E[PPT/附件解析]
    B --> F[IM 日志拉取]
    
    C --> G[文本实体抽取 + 事件抽取]
    D --> H[视觉实体抽取 + 空间关系]
    E --> I[结构化实体 + 版本号]
    F --> J[观点聚类 + 立场分析]
    
    G & H & I & J --> K[跨模态实体对齐]
    K -->|对比学习| L[统一实体空间 Embedding]
    L --> M[证据链构建: 实体 <-SUPPORTED_BY- 证据节点]
    M --> N[冲突检测: 文本说'A' vs 白板画'B']

class MultiModalEvidenceFuser:
    def __init__(self, text_encoder, vision_encoder, audio_encoder):
        self.encoders = {"text": text_encoder, "vision": vision_encoder, "audio": audio_encoder}
        # 可学习的模态权重，初始化为领域先验
        self.modality_weights = nn.Parameter(torch.tensor([0.5, 0.3, 0.2])) 

    def fuse_evidence(self, entity: Entity, evidences: List[EvidenceNode]) -> FusedEntity:
        """
        输入: 核心实体 + 多模态证据列表
        输出: 融合后的实体属性分布 + 不确定性量化
        """
        # 1. 编码所有证据
        embeds = {}
        for ev in evidences:
            embeds[ev.id] = self.encoders[ev.modality](ev.content)
        
        # 2. 计算证据间一致性矩阵
        consistency_matrix = self._compute_consistency(embeds)
        
        # 3. 基于一致性加权聚合 (类似 Attention over Evidence)
        # 如果白板草图与文本纪要在核心属性上冲突，一致性低，权重自动下调
        weights = F.softmax(self.modality_weights * consistency_matrix.mean(dim=1), dim=0)
        
        # 4. 生成融合属性分布 (均值+方差，量化不确定性)
        fused_attrs = {}
        for attr in entity.critical_attributes:
            vals = [self._decode_attr(embeds[eid], attr) for eid in embeds]
            fused_attrs[attr] = GaussianMixture(vals, weights).fit()
            
        return FusedEntity(
            entity_id=entity.id,
            attributes=fused_attrs,
            uncertainty=fused_attrs[entity.primary_key].variance, # 主键属性方差作为不确定性指标
            evidence_lineage=[e.id for e in evidences]
        )

MATCH (d:Decision {name: "订单服务拆分"})-[:HAS_VERSION]->(v:DecisionVersion {version: "v3.2"})
OPTIONAL MATCH (v)<-[:SUPPORTED_BY]-(e:EvidenceNode)
WHERE e.modality IN ["WHITEBOARD", "PPT_SLIDE", "AUDIO_SEGMENT", "IM_THREAD"]
RETURN 
    v.decision_content AS 文本决策,
    collect(CASE WHEN e.modality="WHITEBOARD" THEN e.minio_url END) AS 白板草图,
    collect(CASE WHEN e.modality="AUDIO_SEGMENT" THEN e.minio_url + "#t=" + e.start_sec END) AS 关键录音片段,
    collect(CASE WHEN e.modality="IM_THREAD" THEN e.summary END) AS 会后讨论要点

package ontology

// 业务指标核心本体定义
BusinessMetric: {
    // 继承基类
    _: CoreEntity & {
        id:     string @id @index(hash)
        name:   string @index(fulltext)
        alias:  [...string] @index(fulltext)
    }
    
    // 核心属性：强制要求计算逻辑可机器解析
    calculation_logic: CalculationLogic @required
    unit:              string & (="CNY" | "USD" | "COUNT" | "RATE" | "DAYS")
    granularity:       Granularity @required  // DAILY | HOURLY | EVENT_LEVEL
    
    // 版本演进约束
    version: VersionInfo @embedded {
        current:     string @pattern("^v\d+\.\d+\.\d+$")
        history: [...VersionSnapshot]
        // 约束：口径变更必须关联审批单
        breaking_change_requires: "APPROVAL_TICKET_ID" 
    }
    
    // 语义约束：用 CEL 表达式定义不变量
    constraints: [
        // 约束 1: 同一租户下指标名唯一
        "unique(name, tenant_id)",
        // 约束 2: 衍生指标必须引用存在的基础指标
        "type == 'DERIVED' => all(ref_metrics, exists(@.id))",
        // 约束 3: 口径变更时，下游报表必须显式迁移或标记废弃
        "version.breaking_change => all(downstream_reports, status in ['MIGRATED', 'DEPRECATED'])"
    ]
}

// 计算逻辑结构化定义 (支持 SQL / DSL / Python UDF)
CalculationLogic: {
    type: "SQL" | "DSL" | "PYTHON"
    expression: string
    dependencies: [...MetricRef] // 显式依赖，用于血缘构建
    params: {...} // 参数化配置，如时间窗口、过滤条件
}

# .gitlab/ci/ontology_change.yml
stages:
  - syntax_check
  - backward_compatibility
  - impact_analysis
  - contract_test
  - deploy_staging

syntax_check:
  script: cue vet ./ontology/...  # 语法/约束校验

backward_compatibility:
  script: |
    # 对比当前版本与主分支版本
    python tools/ontology_diff.py --base main --head $CI_COMMIT_SHA
    # 输出: BREAKING / NON_BREAKING / DEPRECATION 标签
  rules:
    - if: '$BREAKING_CHANGE == "true"'
      when: manual  # 破坏性变更需人工批准
      allow_failure: false

impact_analysis:
  script: |
    # 1. 查询图谱中所有实例化该本体的实体
    # 2. 遍历 DERIVED_FROM / DEPENDS_ON 边，计算受影响下游节点集合
    # 3. 生成影响报告: 受影响报表数、模型特征数、告警规则数、API 调用方
    python tools/impact_analyzer.py --changed-type BusinessMetric --output impact_report.json
  artifacts:
    reports:
      - impact_report.json

contract_test:
  script: |
    # 基于影响报告，自动生成数据契约测试用例
    # 校验：新旧版本在同一份样本数据上，核心指标输出差异是否在阈值内
    python tools/contract_test.py --report impact_report.json --sample-data s3://bucket/golden_set/

-- 1. 版本链建模：使用 Tag 标识版本，Edge 标识演进关系
CREATE TAG IF NOT EXISTS EntityVersion(
    version string, 
    snapshot_json string,  -- 压缩存储完整快照，避免宽表稀疏
    embedding fixed_string(1536), -- 存 float32 数组，或单独存向量库
    change_type string,        -- CREATE/UPDATE/MERGE/SPLIT/DEPRECATE
    operator string,
    timestamp int64
) TTL_DURATION = 259200000, TTL_COL = "timestamp"; -- 3年自动归档冷数据

CREATE EDGE IF NOT EXISTS DERIVED_FROM(
    merge_strategy string,     -- AUTO_MERGE/MANUAL_MERGE/FORK
    confidence double,
    conflict_ids string        -- 关联冲突记录ID
);

-- 2. 业务实体当前态视图：物化视图加速当前态查询
CREATE TAG IF NOT EXISTS EntityCurrent(
    current_version string,
    name string,
    -- 热点属性冗余存储，避免 Join 版本表
    key_attr_1 string, 
    key_attr_2 string
) TTL_DURATION = 0; -- 永久保留

-- 3. 索引策略：仅对高频查询属性建索引，避免写放大
CREATE TAG INDEX IF NOT EXISTS idx_entity_name ON EntityCurrent(name);
CREATE TAG INDEX IF NOT EXISTS idx_entity_version ON EntityVersion(version);
-- 向量索引单独在 Milvus 维护，图库只存 ID 映射

def hybrid_search(query_text: str, filters: dict, top_k: int = 10):
    # 1. 向量召回 (候选集 200)
    vec_results = milvus.search(
        collection="entity_embeddings",
        data=[embed(query_text)],
        filter=build_filter(filters),  # 标量过滤下推
        limit=200,
        params={"ef": 128}
    )
    
    # 2. 图结构二跳召回 (补全向量遗漏的结构相关实体)
    graph_results = nebula.execute(f"""
        MATCH (e:EntityCurrent) 
        WHERE e.name CONTAINS "{extract_keywords(query_text)}" 
        AND {build_where(filters)}
        OPTIONAL MATCH (e)-[:RELATES_TO*1..2]-(n)
        RETURN DISTINCT n.id LIMIT 100
    """)
    
    # 3. RRF (Reciprocal Rank Fusion) 融合
    candidates = rrf_fusion([vec_results, graph_results], k=60)
    
    # 4. 重排：Cross-Encoder 精排 Top 20
    reranked = cross_encoder_rerank(query_text, candidates[:20])
    
    return reranked[:top_k]

# contracts/meeting_minutes/v1.yaml
openapi: 3.1.0
info:
  title: 标准化会议纪要契约
  version: 1.2.0
components:
  schemas:
    MeetingMinutes:
      type: object
      required: [meeting_id, title, start_time, attendees, agenda_items, decisions, action_items, terminology]
      properties:
        meeting_id: {type: string, format: uuid}
        title: {type: string, maxLength: 200}
        agenda_items:
          type: array
          minItems: 1
          items:
            type: object
            required: [topic, owner, duration_min]
            properties:
              topic: {type: string}
              owner: {type: string, format: employee_id}
              duration_min: {type: integer, minimum: 5}
        decisions:
          type: array
          items:
            type: object
            required: [decision_id, content, status, related_entities]
            properties:
              decision_id: {type: string, pattern: "^DEC-\d+$"}
              content: {type: string, minLength: 20}  # 强制详细描述
              status: {enum: [PROPOSED, APPROVED, REJECTED, DEFERRED]}
              related_entities:  # 关联图谱实体，前端自动补全
                type: array
                items: {type: string, format: entity_uri}
        action_items:
          type: array
          items:
            type: object
            required: [action_id, description, assignee, due_date, related_entity]
            properties:
              action_id: {type: string, pattern: "^ACT-\d+$"}
              assignee: {type: string, format: employee_id}
              due_date: {type: string, format: date}
              related_entity: {type: string, format: entity_uri} # 关联需求/缺陷/架构决策
        terminology:  # 会议新增/变更术语，驱动本体更新
          type: array
          items:
            type: object
            required: [term, definition, change_type]
            properties:
              term: {type: string}
              definition: {type: string}
              change_type: {enum: [NEW, UPDATED, DEPRECATED, ALIAS_ADDED]}

# 1. 延迟: 融合引擎 P99 延迟
histogram_quantile(0.99, rate(fusion_engine_latency_seconds_bucket[5m])) > 0.5

# 2. 流量: 版本发布吞吐
rate(fusion_version_committed_total[1m])

# 3. 错误: 冲突消解失败率
rate(conflict_resolution_failed_total[5m]) / rate(conflict_resolution_total[5m]) > 0.01

# 4. 饱和度: 图库存储/内存/CPU
# 存储: (node_filesystem_size_bytes - node_filesystem_free_bytes) / node_filesystem_size_bytes > 0.8
# 内存: (container_memory_usage_bytes / container_spec_memory_limit_bytes) > 0.85
# CPU: rate(container_cpu_usage_seconds_total[5m]) > 0.9

# 语义冲突自动消解率 (核心价值指标)
rate(conflict_auto_resolved_total[1h]) / rate(conflict_detected_total[1h])

# 版本回滚次数 (稳定性风险信号)
increase(graph_version_rollback_total[1h]) > 0

# 知识覆盖率增长 (业务增长信号)
(entity_count_total - entity_count_total offset 7d) / entity_count_total offset 7d