左帮右臂：六大能力闭环联动的开放对象操作系统

核心理念

六大能力（识别、创建、修复、优化、比对、生成）不是孤立动作，而是端到端闭环：

用户说「创建一个类似电机的零件」 -> 识别意图 -> 检索双库 -> 匹配决策 -> 创建/复用 -> 修复补全 -> 优化建议 -> 比对差异 -> 生成输出

现有代码基础（已实现）

Task 1: 六大能力闭环工作流 — 基于双SQLite库的智能对象创建与复用

1.0 双SQLite库角色分工

| 库 | 文件 | 访问权限 | 用途 |

|------|---------|--------|

| 标准库 | server/data/sciot_import.db | 只读 | 13000+工业对象定义、通用规则、属性元数据、序列配置 |

| 企业私有库 | server/data/core_runtime.db | 读写 | 企业自定义对象、规则、工作流、修正记录、审计日志 |

复制机制：从标准库复制到私有库时，记录 source = 'standard'，后续企业可修改副本而不影响标准库。

1.1 端到端闭环流程（识别->检索->匹配->决策->创建/复用->修复/优化->比对->生成）

Step 1: 识别意图与对象特征（IntentEngine + 规则引擎）

输入：「创建一个类似电机的零件，型号M-123，功率5.5kW」

IntentEngine (intent-engine.js) 提取：

• intent: create
• item_type: Part
• features: {name: "电机", model: "M-123", power: 5.5}

规则引擎优先，LLM兆底。

Step 2: 检索私有库（core_runtime.db）— 规则引擎确定性匹配

在 _injectTypeContext() 中增加第10步：查询私有库中已有对象。

// 10. 双库查重：先私有库后标准库
const privateDb = require('../database1').getDatabase();
const standardDb = compat.createDatabase(path.join(__dirname, '..', 'data', 'sciot_import.db'));

// 精确匹配（唯一键）
const kf = context._keyedField;
if (kf && properties[kf]) {
  // 先查私有库
  const privateExisting = privateDb.prepare(
    `SELECT id, name, ${kf} FROM sciot_objects WHERE item_type = ? AND ${kf} = ?`
  ).all(itemType, properties[kf]);
  if (privateExisting.length > 0) {
    context._matchResult = { source: 'private', action: 'reference', items: privateExisting };
  } else {
    // 再查标准库
    const stdExisting = standardDb.prepare(
      `SELECT * FROM sciot_properties WHERE item_type_name = ?`
    ).all(itemType);
    // ... 匹配逻辑
  }
}

// 模糊匹配（加权相似度）
if (!context._matchResult) {
  const similarityRule = { fields: ['name','specification','description'], weights: [0.5,0.3,0.2], threshold: 0.85 };
  // 规则引擎计算相似度
}

新增规则 builtin-create-pre-dedup（在 _loadBuiltinRules() 中）：

{
  id: 'builtin-create-pre-dedup', scope: RULE_SCOPES.CREATE_PRE,
  action_script: `
    var match = context._matchResult;
    if (!match) return {modified: false};
    if (match.action === 'reference') return { action: 'reference', existing_id: match.items[0].id, message: '私有库已存在: ' + match.items[0].name };
    if (match.action === 'copy') return { action: 'copy', source_id: match.items[0].id, source: match.source, message: match.source === 'standard' ? '标准库中找到模板，复制到私有库' : '私有库中找到相似对象' };
    return {modified: false};
  `
}

Step 3: 检索标准库（sciot_import.db 只读）

私有库无匹配时，查询标准库。标准库包含13000+工业对象定义（sciot_properties、sciot_templates）。

查询策略：与私有库相同的精确/模糊匹配，但结果标记 source: 'standard'。

Step 4: 决策引擎

| 情况 | 动作 | 规则引擎返回值 |

|------|------|---------------|

| 私有库精确匹配 | 直接引用已有对象 | {action: 'reference', existing_id: 'xxx'} |

| 私有库模糊匹配(相似度>=0.85) | 推荐相似对象，用户选择复制修改 | {action: 'suggest', candidates: [...]} |

| 标准库匹配 | 复制标准库对象到私有库 | {action: 'copy', source: 'standard', template_id: 'xxx'} |

| 完全不存在 | 调用大模型生成新对象定义 | {action: 'create'} |

Step 5: 创建/复用（useCapabilityCreate.js）

• 引用：返回已有对象ID，不做修改
• 复制修改：基于相似对象或标准库模板，复制属性结构，允许用户修改部分字段
• 全新创建：调用创建节点，根据LLM生成的定义在私有库中插入新对象

Step 6: 修复与优化（CapabilityRuntime.repair + optimize）

• 修复节点：规则引擎自动补全必填字段（如根据sciot_sequences生成物料编码）
• 优化节点：提供改进建议（如「成本可优化10%」）

Step 7: 比对（CapabilityRuntime.compare）

创建完成后，自动与历史版本或标准库模板比对，输出差异报告。

Step 8: 生成（CapabilityRuntime.generate）

生成对象实例 + 自然语言总结：「已创建零件电机M-123，编号PART-20260612-001」

1.2 规则引擎与LLM分工

Task 2: 对象类与n8n工作流双向转换

2.1 对象类 -> n8n节点（已有基础）

packages/@n8n/nodes-langchain/nodes/ 中已有 SCSAI 相关节点。需要：

1. 在 server/core/rule-engine.js 中新增方法 exportAsN8nNode(itemType):

• 从 sciot_properties 生成节点的 input parameters
• 从 sciot_rules_v2 生成节点的 execute 逻辑
• 从 generation_rules 生成 item_properties 处理链

1. 输出格式为标准 n8n node description JSON（参考 SCSAIAI.node.json）

2.2 n8n工作流 -> 对象类（逆向导出）

新增 server/core/workflow-to-schema.js:

• 解析 n8n workflow JSON
• 提取 trigger 节点的输入参数 -> 对象属性
• 提取 action 节点的转换逻辑 -> 规则脚本
• 生成 sciot_templates + sciot_properties + sciot_rules_v2 插入语句

2.3 动态节点注册

利用 n8n 的 community node 机制：

• 在 deploy/ 目录下生成标准 n8n community node 包
• 通过 npm install 动态注册
• 新增对象类时自动生成并安装对应节点

Task 3: 规则自进化闭环

3.1 用户修正采集（已有基础设施）

sciot_rule_history 表已有 user_corrected 字段（line 291）。需要：

1. 在 CapabilityRuntime 各能力方法中新增 reportCorrection(ruleId, originalOutput, correctedOutput) 方法
2. 存储到 sciot_rule_history.user_corrected = 1 + 新增 sciot_corrections 表：

CREATE TABLE sciot_corrections (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  rule_id TEXT,
  item_type TEXT,
  scope TEXT,
  original_output TEXT,  -- JSON
  corrected_output TEXT,  -- JSON
  diff_summary TEXT,      -- LLM 生成的差异摘要
  pattern_detected TEXT,  -- 大模型识别的修正模式
  created_at TEXT DEFAULT (datetime('now','localtime'))
);

3.2 规则建议生成（大模型驱动）

新增 server/core/rule-evolution.js:

class RuleEvolution {
  // 定期分析 corrections 表，生成规则候选
  async analyzeCorrections(itemType, threshold = 5) {
    // 1. 查询 user_corrected=1 的记录（>= threshold 条）
    // 2. 用大模型总结修正模式
    // 3. 生成 condition_script + action_script
    // 4. 存入 sciot_rule_candidates 表（待审批）
  }
  
  // 审批后激活规则
  async approveRule(candidateId) {
    // 从 candidates 表移入 sciot_rules_v2 表
    // 清除规则缓存
  }
}

3.3 规则效能监控

利用已有的 sciot_rules_v2.hit_count + avg_duration_ms + user_correction_count 字段：

• 自动降级：user_correction_count / hit_count > 0.3 的规则自动标记为 is_active = 0
• 推荐优化：hit_count 高但 avg_duration_ms 也高的规则，建议用确定性脚本替代 LLM

Task 4: 用户开放工具

4.1 对象建模智能体（对话式建表）

新增 server/core/object-modeler.js:

class ObjectModeler {
  // 自然语言 -> JSON Schema
  async defineObject(naturalLanguageDesc) {
    // 1. LLM 解析自然语言为字段列表
    // 2. 推断数据类型（string/integer/list/item）
    // 3. 推断约束（required/unique/length）
    // 4. 生成 sciot_properties 插入语句
    // 5. 生成 sciot_templates 插入语句
    // 6. 生成 generation_rules（item_properties、default_permission）
    // 7. 用户确认后执行插入
  }
}

4.2 规则可视化编辑器

前端新增 src/views/RuleEditor.vue:

• 条件构建器：[字段] [操作符] [值] 下拉选择
• 动作构建器：[设置字段] [为值] / [发送通知] / [调用LLM]
• 高级模式：直接编辑 condition_script / action_script
• 通过 /api/rules API 调用 rule-engine.js 的 saveRule() 方法

4.3 工作流编排

利用现有 n8n 集成（start-n8n-mysql.bat 启动完整 n8n）：

• BossAgents 的六大能力封装为 n8n 自定义节点
• 每个节点内部调用 CapabilityRuntime 对应方法
• 用户拖拽连接节点即可编排跨系统工作流

实现优先级排序

PPT 架构图（基于真实代码）

[用户层]
  对象建模智能体 ── ObjectModeler.defineObject()
  规则可视化编辑器 ── RuleEditor.vue -> /api/rules
  n8n工作流画布 ── CapabilityRuntime 6能力节点

[核心引擎层]
  IntentEngine (意图识别) -> UnifiedRuleEngine (9 scope)
  CapabilityRuntime (6能力闭环联动)
  RuleEvolution (自进化) -> sciot_corrections (修正库)

[双SQLite数据层]
  sciot_import.db (标准库,只读,13000+工业对象)     core_runtime.db (企业私有库,可读写)
  sciot_properties (属性元数据)                     sciot_objects (企业对象实例)
  sciot_templates (对象模板)                         sciot_rules_v2 (企业自定义规则)
  sciot_sequences (编号序列)                        sciot_corrections (修正记录)

示例演示：创建「电机M-123」

用户输入：「创建一个类似电机的零件，型号M-123，功率5.5kW」

执行过程：

1. 识别：规则引擎提取 type=Part, name=电机, model=M-123, power=5.5，意图create
2. 私有库检索：精确匹配 model='M-123'，无结果；模糊匹配 name like '%电机%'，返回「电机M-100」（相似度0.78），低于阈值0.85
3. 标准库检索：查询到「电机模板」（相似度0.72），系统提示「标准库中找到电机模板，是否复制后修改？」
4. 用户确认「是」
5. 复制到私有库：复制标准库的Part对象定义，生成新对象
6. 修复：规则引擎检查必填字段「物料编号」缺失，自动生成「PART-20260612-001」
7. 优化：检查成本为空，提示「建议补充成本信息」
8. 比对：与标准库模板比对，输出差异报告
9. 生成：返回对象ID，「已创建零件电机M-123，编号PART-20260612-001」

演讲话术建议

「评委老师，我们六大能力不是孤立的。以创建对象为例——用户说『创建一个类似电机的零件』，系统不会盲目新建，而是先去私有库查有没有现成的，再去标准库找模板。

我们的底层是双SQLite库设计：标准库包含13000多个工业对象定义，是所有企业共享的知识底座；私有库承载每个企业自己的对象、规则和修正记录。

如果有相似的，就推荐用户复制修改。这样既避免了数据冗余，又充分利用了标准库的工业知识。整个过程规则引擎和模型协同，用户感觉就像有个懂业务的助理在帮忙。

更关键的是自进化闭环：用户的每一次手动修正，都会被系统记录。当同一类修正积累到一定数量，系统会自动生成新规则候选。管理员确认后，规则立即生效。这意味着系统越用越聪明。

这就是工业智能体的终极形态——让每个企业都拥有自己的、会进化的AI员工团队。」

通过这套机制，左帮右臂实现了任意对象的高效创建与复用，符合企业实际工作习惯，也体现了平台的智能性和开放性。