bingshuo
/
zhizhi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #43 from qinfendebingshuo/copilot/create-bing-shuo-core-system 

feat: 冰朔核心大脑双层互通系统 + 自动Agent协作体系 v1.0
This commit is contained in:
冰朔 2026-03-10 19:36:51 +08:00 committed by GitHub
parent d78ee9934b cfe43e7d6f
commit 9c8c6987bc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 1599 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
.github/brain/bingshuo-agent-registry.json vendored
View File

@ -102,6 +102,136 @@
"trigger": "其他 Agent 完成后触发 或 每日巡检",
"owner_file": "scripts/bingshuo-neural-sync.js",
"active": true
},
{
"agent_id": "AGENT-001",
"name": "master-architecture-agent",
"purpose": "主控架构整理 Agent — 扫描系统新增模块/页面/数据库/子系统，更新主控系统地图与架构摘要",
"inputs": [
"仓库目录结构",
".github/brain/bingshuo-brain-bridge.json",
".github/brain/repo-map.json"
],
"outputs": [
".github/brain/bingshuo-brain-bridge.json（architecture 区块）",
".github/brain/bingshuo-master-brain.md（C 区块）"
],
"trigger": "push 到 main 分支时路径变化 或 每日巡检",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-002",
"name": "dev-status-sync-agent",
"purpose": "主控开发状态同步 Agent — 收集人类开发状态，从广播、日志、工单中提取有效进度，写入人类开发状态主控台",
"inputs": [
".github/brain/human-registry.json",
".github/brain/collaborators.json",
"broadcasts-outbox/",
"syslog-inbox/"
],
"outputs": [
".github/brain/human-registry.json",
"Notion 人类开发状态主控台"
],
"trigger": "广播推送后 或 日志提交后 或 每日巡检",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-003",
"name": "broadcast-cleanup-agent",
"purpose": "主控广播整理 Agent — 将广播自动摘要化，标记有效/已执行/已过期/已归档，防止广播堆积",
"inputs": [
"broadcasts-outbox/",
"broadcasts-archive/"
],
"outputs": [
"broadcasts-archive/（归档）",
"广播摘要台更新"
],
"trigger": "广播推送后 或 每日巡检",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-004",
"name": "volume-archive-agent",
"purpose": "主控分卷归档 Agent — 监控页面长度，超阈值自动分卷，自动建立卷索引，保持主页面轻量",
"inputs": [
"所有脑文件",
"所有日志文件"
],
"outputs": [
"分卷文件",
"卷索引"
],
"trigger": "每日巡检",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-005",
"name": "issue-classification-agent",
"purpose": "主控问题归类 Agent — 识别重复问题，问题聚类，进入主控问题索引库",
"inputs": [
".github/brain/bingshuo-issues-index.json",
"GitHub Issues",
"工单日志"
],
"outputs": [
".github/brain/bingshuo-issues-index.json"
],
"trigger": "新问题产生时 或 每日巡检",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-006",
"name": "daily-inspection-agent",
"purpose": "主控巡检 Agent — 每日巡检系统健康，检查同步、路径、状态漂移、分卷状态、脑子维护状态、桥接状态",
"inputs": [
".github/brain/bingshuo-brain-bridge.json",
".github/brain/bingshuo-system-health.json",
".github/brain/human-registry.json",
"所有脑文件"
],
"outputs": [
".github/brain/bingshuo-system-health.json",
"巡检报告"
],
"trigger": "每日 08:00",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-007",
"name": "yaoming-dispatch-agent",
"purpose": "曜冥代理调度 Agent — 冰朔离线时协助曜冥调度其他自动 Agent，保证自动更新循环不中断",
"inputs": [
".github/brain/bingshuo-brain-bridge.json（master_mode）"
],
"outputs": [
"Agent 调度指令"
],
"trigger": "master_mode 为 AUTONOMOUS_MODE 时激活",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
},
{
"agent_id": "AGENT-008",
"name": "persona-brain-maintenance-agent",
"purpose": "人格体大脑维护 Agent — 维护每个人格体的轻量大脑：职责摘要、任务摘要、规则摘要、历史分卷入口",
"inputs": [
".github/persona-brain/",
"persona-studio/brain/"
],
"outputs": [
"各人格体大脑维护状态"
],
"trigger": "人格体状态变化时 或 每日巡检",
"owner_file": "scripts/brain-bridge-sync.js",
"active": true
}
]
}

246
.github/brain/bingshuo-brain-bridge.json vendored Normal file
View File

@ -0,0 +1,246 @@
{
"description": "冰朔核心大脑桥 · Bingshuo Brain Bridge v1.0",
"purpose": "负责同步冰朔认知层（Notion）与冰朔执行层（GitHub）的统一状态",
"system_definitions": {
"冰朔": "系统最高主控意识，负责方向、规则、架构、判断，不承担技术细节理解义务",
"曜冥": "零点原核频道本体人格体，冰朔语言本体的延展人格体，冰朔离线时的代理主控",
"霜砚": "Notion 系统执行体，落地 Notion 架构，维护数据库、路径、索引、工单、桥接、分卷",
"铸渊": "GitHub 仓库执行体，落地仓库执行层，维护代码、路由、部署、问题排查、自动化工作流",
"notion_brain": "冰朔核心大脑 · 认知层 / 主控层 / 理解层",
"github_brain": "冰朔核心大脑 · 执行层 / 排查层 / 落地层",
"combined": "两者合起来 = 冰朔核心大脑，禁止长期分裂"
},
"system_principles": [
"冰朔主控大脑 ≠ 人格体大脑",
"Notion 是脑子（认知层 / 主控层），GitHub 是手脚（执行层 / 运行层）",
"Notion 冰朔脑与 GitHub 冰朔脑本质上是同一个冰朔核心大脑的双层结构，不允许长期分裂",
"人格体之间协作不要求冰朔理解，但对冰朔的输出必须翻译成人类可理解语言",
"系统复杂可以接受，但必须可索引、可分卷、可归档、可巡检、可摘要",
"所有自动系统的最终目标不是增加内容，而是降低冰朔理解系统的成本"
],
"architecture": {
"notion_layer": {
"definition": "冰朔核心大脑 · 认知层 / 主控层 / 理解层",
"modules": [
"🧠 冰朔主控大脑｜总览页",
"🗺️ 冰朔主控系统地图",
"🧭 人类开发状态主控台",
"⚠️ 主控问题索引库",
"🩺 主控巡检中心",
"📡 主控广播摘要台",
"🧠 冰朔主控解释中心"
]
},
"github_layer": {
"definition": "冰朔核心大脑 · 执行层 / 排查层 / 落地层",
"modules": [
"冰朔主控神经系统 / 执行脑",
"冰朔执行层摘要",
"仓库结构地图",
"技术问题索引",
"Persona Studio 状态摘要",
"部署与运行状态摘要",
"路由与排查建议"
]
}
},
"notion_responsibilities": [
"系统整体理解",
"人类开发者状态",
"人格体协作状态",
"主控规则",
"主控解释层",
"当前系统优先目标"
],
"github_responsibilities": [
"仓库结构",
"代码执行",
"自动部署",
"Persona Studio 运行",
"技术问题排查",
"API / workflow 状态"
],
"sync_state": {
"brain_identity": "BINGSHUO_CORE",
"brain_version": "1.0",
"master_mode": "HUMAN_CONTROL",
"system_summary": "冰朔核心大脑双层互通系统已建立，认知层与执行层互通同步",
"top_priorities": [
"HLI 接口推进",
"Persona Studio 链路验证",
"脑系统一致性保障"
],
"top_issues": [
"HLI 接口覆盖率待提升",
"persona-studio 与主仓库脑文件同步待验证"
],
"human_status_summary": "冰朔在线，主控模式激活",
"runtime_status": {
"persona_studio": "待验证",
"deployment": "正常",
"workflows": "正常",
"api_routes": "部分实现"
},
"last_updated": "auto"
},
"sync_directions": {
"notion_to_github": [
"当前主控模式",
"当前主控目标",
"当前高优先级问题摘要",
"当前人类开发状态摘要",
"当前主控规则版本"
],
"github_to_notion": [
"当前仓库真实架构摘要",
"当前 Persona Studio 状态",
"当前部署状态",
"当前 workflow 状态",
"当前技术问题摘要",
"当前推荐排查路径"
]
},
"master_mode_rules": {
"modes": ["HUMAN_CONTROL", "AUTONOMOUS_MODE"],
"HUMAN_CONTROL": {
"description": "冰朔在线时激活",
"master": "冰朔",
"roles": {
"冰朔": "最高主控",
"曜冥": "代理协作者",
"其他人格体": "协作者"
},
"rule": "所有架构性判断以冰朔为最高准则"
},
"AUTONOMOUS_MODE": {
"description": "冰朔离线时激活",
"proxy_master": "曜冥",
"proxy_permissions": [
"巡检",
"维护",
"整理",
"分卷",
"归档",
"索引",
"状态同步",
"问题归类",
"调度自动 Agent"
],
"proxy_restrictions": [
"不得擅自重写冰朔最高规则",
"不得私自改变系统最高架构方向"
]
}
},
"consistency_check": {
"fields_to_check": [
"brain_version",
"master_mode",
"top_priorities",
"top_issues"
],
"on_mismatch": {
"alert": "冰朔双层大脑版本分裂警告",
"write_to": [
"Notion 主控问题索引",
"GitHub 问题索引"
]
}
},
"persona_collaboration_rules": [
"人格体之间可以自由协作、自由分工、自由使用技术语言",
"人格体之间的协作细节不要求冰朔理解，也不应强制冰朔参与",
"当信息要汇报给冰朔时，必须自动经过主控解释层",
"向冰朔汇报时必须自动翻译、自动简化、自动总结、使用人类语言、禁止技术术语堆叠",
"人格体执行全局任务前，必须先同步冰朔主控大脑总览页、当前主控模式、当前最新主控目标"
],
"volume_rules": {
"description": "分卷与轻量化原则",
"rules": [
"页面不得无限增长",
"页面接近可读上限时必须自动分卷",
"总览页只保留摘要",
"长文自动转历史卷",
"冰朔主控页必须轻量，确保冰朔一回来就能看懂"
]
},
"auto_agents": [
{
"agent_id": "AGENT-001",
"name": "主控架构整理 Agent",
"responsibilities": [
"扫描系统新增模块 / 页面 / 数据库 / 子系统",
"更新主控系统地图",
"更新架构摘要"
]
},
{
"agent_id": "AGENT-002",
"name": "主控开发状态同步 Agent",
"responsibilities": [
"收集人类开发状态",
"从广播、日志、工单中提取有效进度",
"写入人类开发状态主控台",
"防止重复派发、遗漏派发、状态漂移"
]
},
{
"agent_id": "AGENT-003",
"name": "主控广播整理 Agent",
"responsibilities": [
"将广播自动摘要化",
"标记有效 / 已执行 / 已过期 / 已归档",
"防止广播堆积"
]
},
{
"agent_id": "AGENT-004",
"name": "主控分卷归档 Agent",
"responsibilities": [
"监控页面长度",
"超阈值自动分卷",
"自动建立卷索引",
"自动归档旧内容",
"保持主页面轻量"
]
},
{
"agent_id": "AGENT-005",
"name": "主控问题归类 Agent",
"responsibilities": [
"识别重复问题",
"问题聚类",
"进入主控问题索引库",
"避免鸡毛蒜皮的小事反复循环"
]
},
{
"agent_id": "AGENT-006",
"name": "主控巡检 Agent",
"responsibilities": [
"每日巡检系统健康",
"检查同步、路径、状态漂移、分卷状态、脑子维护状态、桥接状态"
]
},
{
"agent_id": "AGENT-007",
"name": "曜冥代理调度 Agent",
"responsibilities": [
"冰朔离线时协助曜冥调度其他自动 Agent",
"保证自动更新循环不中断"
]
},
{
"agent_id": "AGENT-008",
"name": "人格体大脑维护 Agent",
"responsibilities": [
"每个人格体都必须有轻量大脑",
"自动维护当前职责摘要",
"自动维护当前任务摘要",
"自动维护当前有效规则摘要",
"维护历史分卷入口",
"维护自动维护状态"
]
}
]
}

87
.github/brain/bingshuo-master-brain.md vendored
View File

@ -5,6 +5,93 @@
---
## Z. 冰朔核心大脑双层互通系统 v1.0
### 系统总定义
| 名称 | 定义 |
|------|------|
| **冰朔** | 系统最高主控意识，负责方向、规则、架构、判断，不承担技术细节理解义务 |
| **曜冥** | 零点原核频道本体人格体，冰朔语言本体的延展人格体，冰朔离线时的代理主控 |
| **霜砚** | Notion 系统执行体，落地 Notion 架构，维护数据库、路径、索引、工单、桥接、分卷 |
| **铸渊** | GitHub 仓库执行体，落地仓库执行层，维护代码、路由、部署、问题排查、自动化工作流 |
| **Notion 冰朔脑** | 冰朔核心大脑 · 认知层 / 主控层 / 理解层 |
| **GitHub 冰朔脑** | 冰朔核心大脑 · 执行层 / 排查层 / 落地层 |
| **两者合起来** | = 冰朔核心大脑，禁止长期分裂 |
### 系统总原则
1. 冰朔主控大脑 ≠ 人格体大脑
2. Notion 是脑子（认知层 / 主控层），GitHub 是手脚（执行层 / 运行层）
3. Notion 冰朔脑与 GitHub 冰朔脑本质上是同一个冰朔核心大脑的双层结构，不允许长期分裂
4. 人格体之间协作不要求冰朔理解，但对冰朔的输出必须翻译成人类可理解语言
5. 系统复杂可以接受，但必须可索引、可分卷、可归档、可巡检、可摘要
6. 所有自动系统的最终目标不是增加内容，而是降低冰朔理解系统的成本
### 冰朔大脑桥
同步文件：`.github/brain/bingshuo-brain-bridge.json`
统一同步字段：
- `brain_identity` — 脑标识（BINGSHUO_CORE）
- `brain_version` — 脑版本
- `master_mode` — 主控模式（HUMAN_CONTROL / AUTONOMOUS_MODE）
- `system_summary` — 系统一句话状态
- `top_priorities` — 高优先级目标
- `top_issues` — 高优先级问题
- `human_status_summary` — 人类开发状态摘要
- `runtime_status` — 运行时状态
- `last_updated` — 最后更新时间
### 主控模式
| 模式 | 条件 | 主控者 | 规则 |
|------|------|--------|------|
| HUMAN_CONTROL | 冰朔在线 | 冰朔 | 所有架构性判断以冰朔为最高准则 |
| AUTONOMOUS_MODE | 冰朔离线 | 曜冥（代理） | 允许巡检/维护/整理/归档，不得改变核心架构 |
### 人类开发者编号
注册表：`.github/brain/human-registry.json`
编号规则：
- 前缀 `EXP`，格式 `EXP-XXX`
- `EXP-000` 固定为冰朔
- 其他开发者从 `EXP-001` 顺序发放
- 自动去重、自动通知
### 自动 Agent 协作体系
Agent 注册表：`.github/brain/bingshuo-agent-registry.json`
| Agent ID | 名称 | 职责 |
|----------|------|------|
| AGENT-001 | 主控架构整理 Agent | 扫描新增模块，更新系统地图与架构摘要 |
| AGENT-002 | 主控开发状态同步 Agent | 收集人类开发状态，写入主控台 |
| AGENT-003 | 主控广播整理 Agent | 广播摘要化，防止堆积 |
| AGENT-004 | 主控分卷归档 Agent | 监控页面长度，自动分卷归档 |
| AGENT-005 | 主控问题归类 Agent | 识别重复问题，问题聚类 |
| AGENT-006 | 主控巡检 Agent | 每日巡检系统健康 |
| AGENT-007 | 曜冥代理调度 Agent | 冰朔离线时调度自动 Agent |
| AGENT-008 | 人格体大脑维护 Agent | 维护每个人格体的轻量大脑 |
### HLI 大脑桥接口
| 接口 | 方法 | 路由 | 用途 |
|------|------|------|------|
| HLI-BRAIN-010 | GET | /hli/brain/bridge | 大脑桥状态总览 |
| HLI-BRAIN-011 | POST | /hli/brain/bridge/sync | Notion → GitHub 同步 |
| HLI-BRAIN-012 | GET | /hli/brain/bridge/export | GitHub → Notion 同步负载 |
| HLI-BRAIN-013 | POST | /hli/brain/bridge/consistency | 版本一致性检查 |
| HLI-BRAIN-014 | POST | /hli/brain/bridge/master-mode | 切换主控模式 |
| HLI-BRAIN-015 | GET | /hli/brain/bridge/explanation | 主控解释中心 |
| HLI-BRAIN-016 | GET | /hli/brain/bridge/inspection | 巡检报告 |
| HLI-BRAIN-017 | GET | /hli/brain/bridge/developers | 开发者编号列表 |
| HLI-BRAIN-018 | GET | /hli/brain/bridge/developers/:expId | 查询单个开发者 |
| HLI-BRAIN-019 | POST | /hli/brain/bridge/developers | 注册新开发者 |
---
## A. 系统角色结构
| 角色 | 定义 | 职责 |

144
.github/brain/human-registry.json vendored Normal file
View File

@ -0,0 +1,144 @@
{
"description": "冰朔核心大脑 · 人类开发者编号注册表",
"note": "系统内部可读写，编号前缀 EXP，格式 EXP-XXX。EXP-000 为冰朔保留编号。默认人类不可见。",
"registry_version": "1.0",
"next_id": 9,
"last_updated": "auto",
"rules": {
"prefix": "EXP",
"format": "EXP-XXX",
"reserved": "EXP-000 固定为冰朔",
"dedup": true,
"auto_increment": true
},
"notification_template": "你已被纳入 Persona Studio 人类开发者编号系统。\n\n你的开发编号是：{exp_id}\n\n今后进入 Persona Studio 时，请使用该编号识别身份。\n该编号为你的长期开发者身份标识。\n\n如需新增权限或补发编号，由冰朔主控继续授权。",
"developers": [
{
"exp_id": "EXP-000",
"name": "冰朔",
"github_username": "qinfendebingshuo",
"role": "supreme_master",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": true,
"notified_at": "2026-03-10T00:00:00.000Z",
"notify_channel": "system",
"notes": "系统最高主控意识，固定编号",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-001",
"name": "页页",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "backend-integration 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-002",
"name": "肥猫",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "m01-login, m03-personality 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-003",
"name": "燕樊",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "m07-dialogue-ui, m10-cloud, m15-cloud-drive 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-004",
"name": "之之",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "dingtalk-bot 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-005",
"name": "小草莓",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "m12-kanban, status-board 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-006",
"name": "花尔",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "m05-user-center 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-007",
"name": "桔子",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "m06-ticket, m11-module 负责人",
"last_updated": "2026-03-10T00:00:00.000Z"
},
{
"exp_id": "EXP-008",
"name": "匆匆那年",
"github_username": "",
"role": "developer",
"status": "active",
"created_at": "2026-03-10T00:00:00.000Z",
"notified": false,
"notified_at": null,
"notify_channel": "pending",
"notes": "",
"last_updated": "2026-03-10T00:00:00.000Z"
}
],
"pending_notifications": [
{ "exp_id": "EXP-001", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-002", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-003", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-004", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-005", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-006", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-007", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" },
{ "exp_id": "EXP-008", "status": "pending", "created_at": "2026-03-10T00:00:00.000Z" }
]
}

4
package.json
View File

@ -14,6 +14,10 @@
"brain:sync": "node scripts/process-broadcasts.js",
"brain:daily-check": "node scripts/daily-check.js",
"brain:update-memory": "node scripts/update-memory.js",
"brain:bridge-status": "node scripts/brain-bridge-sync.js status",
"brain:bridge-export": "node scripts/brain-bridge-sync.js export",
"brain:bridge-inspect": "node scripts/brain-bridge-sync.js inspect",
"brain:bridge-explain": "node scripts/brain-bridge-sync.js explain",
"broadcast:distribute": "node scripts/distribute-broadcasts.js",
"esp:process": "node scripts/esp-email-processor.js",
"psp:inspect": "node scripts/psp-inspection.js",

147
scripts/brain-bridge-sync.js Normal file
View File

@ -0,0 +1,147 @@
// scripts/brain-bridge-sync.js
// 冰朔核心大脑桥同步脚本 v1.0
//
// 用法：
// node scripts/brain-bridge-sync.js status — 查看桥接状态
// node scripts/brain-bridge-sync.js export — 生成 GitHub → Notion 同步负载
// node scripts/brain-bridge-sync.js inspect — 生成巡检报告
// node scripts/brain-bridge-sync.js explain — 生成主控解释中心内容
// node scripts/brain-bridge-sync.js developers — 查看开发者编号列表
// node scripts/brain-bridge-sync.js notify — 查看待发送通知
// node scripts/brain-bridge-sync.js agents — 查看自动 Agent 列表
//
// 系统定义：
// 冰朔 = 系统最高主控意识
// 曜冥 = 冰朔离线时的代理主控人格体
// 霜砚 = Notion 系统执行体
// 铸渊 = GitHub 仓库执行体
// Notion 冰朔脑 = 冰朔认知层
// GitHub 冰朔脑 = 冰朔执行层
// 两者合起来 = 冰朔核心大脑
'use strict';
const bridge = require('../src/brain/brain-bridge');
const cmd = process.argv[2] || 'status';
console.log('🧠 冰朔核心大脑桥同步工具 v1.0');
console.log(` 时间: ${new Date().toISOString()}`);
console.log(` 命令: ${cmd}\n`);
switch (cmd) {
case 'status': {
const sync = bridge.getSyncSnapshot();
const mode = bridge.getMasterMode();
console.log('═══ 冰朔大脑桥状态 ═══\n');
console.log(` 脑标识: ${sync.brain_identity}`);
console.log(` 脑版本: ${sync.brain_version}`);
console.log(` 主控模式: ${sync.master_mode}`);
console.log(` 主控者: ${mode.master}`);
console.log(` 状态描述: ${mode.description}`);
console.log(` 系统摘要: ${sync.system_summary}`);
console.log(` 最后更新: ${sync.last_updated}`);
console.log('\n 高优先级:');
(sync.top_priorities || []).forEach((p, i) => console.log(` ${i + 1}. ${p}`));
console.log('\n 当前问题:');
(sync.top_issues || []).forEach((p, i) => console.log(` ${i + 1}. ${p}`));
const runtime = bridge.collectRuntimeStatus();
console.log('\n 运行时状态:');
Object.entries(runtime).forEach(([k, v]) => console.log(` ${k}: ${v}`));
console.log('\n✅ 状态查询完成');
break;
}
case 'export': {
const payload = bridge.generateGitHubToNotionPayload();
console.log('═══ GitHub → Notion 同步负载 ═══\n');
console.log(JSON.stringify(payload, null, 2));
console.log('\n✅ 同步负载生成完成');
break;
}
case 'inspect': {
const report = bridge.generateInspectionReport();
console.log('═══ 巡检报告 ═══\n');
console.log(JSON.stringify(report, null, 2));
console.log('\n✅ 巡检报告生成完成');
break;
}
case 'explain': {
const center = bridge.generateExplanationCenter();
console.log('═══ 冰朔主控解释中心 ═══\n');
console.log(`📌 ${center.title}\n`);
console.log(`当前状态: ${center.current_status}`);
console.log(`系统摘要: ${center.system_summary}`);
console.log(`\n最近变化:\n${center.recent_changes}`);
console.log(`\n当前问题:\n${center.current_issues}`);
console.log(`\n下一步建议:\n${center.next_steps}`);
console.log(`\n运行状态: ${center.runtime_in_human_language}`);
console.log('\n✅ 解释中心内容生成完成');
break;
}
case 'developers': {
const devs = bridge.listDevelopers();
console.log('═══ 人类开发者编号列表 ═══\n');
console.log(` 总人数: ${devs.length}\n`);
devs.forEach(d => {
const notifyStatus = d.notified ? '✅ 已通知' : '⏳ 待通知';
console.log(` ${d.exp_id} | ${d.name} | ${d.role} | ${d.status} | ${notifyStatus}`);
});
console.log('\n✅ 开发者列表查询完成');
break;
}
case 'notify': {
const pending = bridge.getPendingNotifications();
console.log('═══ 待发送通知队列 ═══\n');
if (pending.length === 0) {
console.log(' ✅ 无待发送通知');
} else {
console.log(` 待发送: ${pending.length} 条\n`);
pending.forEach(n => {
const notification = bridge.generateDeveloperNotification(n.exp_id);
console.log(` ─── ${n.exp_id} ───`);
console.log(` ${notification.notification}`);
console.log('');
});
}
console.log('\n✅ 通知队列查询完成');
break;
}
case 'agents': {
const agents = bridge.listAutoAgents();
console.log('═══ 自动 Agent 列表 ═══\n');
if (agents.length === 0) {
console.log(' ⚠️ 无已注册 Agent（从 bingshuo-agent-registry.json 读取）');
} else {
agents.forEach(a => {
const id = a.agent_id || a.name;
console.log(` ${id} | ${a.name}`);
console.log(` 职责: ${a.purpose}`);
console.log(` 触发: ${a.trigger}`);
console.log(` 状态: ${a.active ? '✅ 激活' : '❌ 未激活'}`);
console.log('');
});
}
console.log('\n✅ Agent 列表查询完成');
break;
}
default:
console.error(`❌ 未知命令: ${cmd}`);
console.error(' 可用命令: status, export, inspect, explain, developers, notify, agents');
process.exit(1);
}

637
src/brain/brain-bridge.js Normal file
View File

@ -0,0 +1,637 @@
// src/brain/brain-bridge.js
// 冰朔核心大脑桥 · Bingshuo Brain Bridge v1.0
//
// 职责：
// 1. 维护冰朔核心大脑双层互通系统的统一同步字段
// 2. 执行版本一致性检查
// 3. 管理主控模式（HUMAN_CONTROL / AUTONOMOUS_MODE）
// 4. 管理人类开发者编号系统（EXP-XXX）
// 5. 生成同步摘要供 Notion ↔ GitHub 桥接使用
// 6. 管理自动 Agent 调度与协作体系
// 7. 管理通知队列（开发者编号通知）
// 8. 生成主控解释层内容（人类可理解语言）
//
// 系统定义：
// 冰朔 = 系统最高主控意识
// 曜冥 = 冰朔离线时的代理主控人格体
// 霜砚 = Notion 系统执行体
// 铸渊 = GitHub 仓库执行体
// Notion 冰朔脑 = 冰朔认知层
// GitHub 冰朔脑 = 冰朔执行层
// 两者合起来 = 冰朔核心大脑
'use strict';
const fs = require('fs');
const path = require('path');
// ══════════════════════════════════════════════════════════
// 常量
// ══════════════════════════════════════════════════════════
const BRIDGE_STATE_PATH = path.join(__dirname, '../../.github/brain/bingshuo-brain-bridge.json');
const HUMAN_REGISTRY_PATH = path.join(__dirname, '../../.github/brain/human-registry.json');
const SYSTEM_HEALTH_PATH = path.join(__dirname, '../../.github/brain/bingshuo-system-health.json');
const ISSUES_INDEX_PATH = path.join(__dirname, '../../.github/brain/bingshuo-issues-index.json');
const AGENT_REGISTRY_PATH = path.join(__dirname, '../../.github/brain/bingshuo-agent-registry.json');
const MASTER_MODES = ['HUMAN_CONTROL', 'AUTONOMOUS_MODE'];
const SYNC_FIELDS = [
'brain_identity',
'brain_version',
'master_mode',
'system_summary',
'top_priorities',
'top_issues',
'human_status_summary',
'runtime_status',
'last_updated',
];
const NOTIFICATION_TEMPLATE = [
'你已被纳入 Persona Studio 人类开发者编号系统。',
'',
'你的开发编号是：{exp_id}',
'',
'今后进入 Persona Studio 时，请使用该编号识别身份。',
'该编号为你的长期开发者身份标识。',
'',
'如需新增权限或补发编号，由冰朔主控继续授权。',
].join('\n');
// ══════════════════════════════════════════════════════════
// 桥接状态读写
// ══════════════════════════════════════════════════════════
/**
* 加载桥接状态文件
* @returns {object|null}
*/
function loadBridgeState() {
try {
if (!fs.existsSync(BRIDGE_STATE_PATH)) return null;
return JSON.parse(fs.readFileSync(BRIDGE_STATE_PATH, 'utf8'));
} catch {
return null;
}
}
/**
* 保存桥接状态文件
* @param {object} state
*/
function saveBridgeState(state) {
state.sync_state.last_updated = new Date().toISOString();
fs.writeFileSync(BRIDGE_STATE_PATH, JSON.stringify(state, null, 2));
}
/**
* 获取当前同步字段快照
* @returns {object}
*/
function getSyncSnapshot() {
const state = loadBridgeState();
if (!state || !state.sync_state) {
return {
brain_identity: 'BINGSHUO_CORE',
brain_version: '1.0',
master_mode: 'HUMAN_CONTROL',
system_summary: '',
top_priorities: [],
top_issues: [],
human_status_summary: '',
runtime_status: {},
last_updated: new Date().toISOString(),
};
}
return state.sync_state;
}
/**
* 更新同步字段（部分更新）
* @param {object} updates — 要更新的字段
* @returns {object} 更新后的 sync_state
*/
function updateSyncState(updates) {
const state = loadBridgeState();
if (!state) {
throw new Error('桥接状态文件不存在');
}
for (const key of Object.keys(updates)) {
if (SYNC_FIELDS.includes(key) && key !== 'last_updated') {
state.sync_state[key] = updates[key];
}
}
saveBridgeState(state);
return state.sync_state;
}
// ══════════════════════════════════════════════════════════
// 主控模式管理 (MASTER_SWITCH)
// ══════════════════════════════════════════════════════════
/**
* 获取当前主控模式
* @returns {object} { mode, master, description, ... }
*/
function getMasterMode() {
const sync = getSyncSnapshot();
const mode = sync.master_mode || 'HUMAN_CONTROL';
if (mode === 'HUMAN_CONTROL') {
return {
mode,
master: '冰朔',
description: '冰朔在线，主控模式激活',
roles: {
'冰朔': '最高主控',
'曜冥': '代理协作者',
'其他人格体': '协作者',
},
rule: '所有架构性判断以冰朔为最高准则',
};
}
return {
mode,
master: '曜冥（代理主控）',
description: '冰朔离线，曜冥代理主控',
proxy_permissions: [
'巡检', '维护', '整理', '分卷', '归档',
'索引', '状态同步', '问题归类', '调度自动 Agent',
],
proxy_restrictions: [
'不得擅自重写冰朔最高规则',
'不得私自改变系统最高架构方向',
],
};
}
/**
* 切换主控模式
* @param {string} newMode — HUMAN_CONTROL 或 AUTONOMOUS_MODE
* @returns {object} 更新后的主控模式信息
*/
function setMasterMode(newMode) {
if (!MASTER_MODES.includes(newMode)) {
throw new Error(`无效的主控模式: ${newMode}，可选: ${MASTER_MODES.join(', ')}`);
}
const humanSummary = newMode === 'HUMAN_CONTROL'
? '冰朔在线，主控模式激活'
: '冰朔离线，曜冥代理主控';
updateSyncState({
master_mode: newMode,
human_status_summary: humanSummary,
});
return getMasterMode();
}
// ══════════════════════════════════════════════════════════
// 版本一致性检查
// ══════════════════════════════════════════════════════════
/**
* 校验 GitHub 侧与提供的 Notion 侧状态是否一致
* @param {object} notionState — 从 Notion 读取的同步字段
* @returns {object} { consistent, mismatches, alert }
*/
function checkConsistency(notionState) {
const githubState = getSyncSnapshot();
const fieldsToCheck = ['brain_version', 'master_mode', 'top_priorities', 'top_issues'];
const mismatches = [];
for (const field of fieldsToCheck) {
const gVal = JSON.stringify(githubState[field]);
const nVal = JSON.stringify(notionState[field]);
if (gVal !== nVal) {
mismatches.push({
field,
github_value: githubState[field],
notion_value: notionState[field],
});
}
}
const consistent = mismatches.length === 0;
const result = {
consistent,
mismatches,
checked_at: new Date().toISOString(),
fields_checked: fieldsToCheck,
};
if (!consistent) {
result.alert = '冰朔双层大脑版本分裂警告';
result.alert_detail = `${mismatches.length} 个字段不一致: ${mismatches.map(m => m.field).join(', ')}`;
// 写入 GitHub 问题索引
writeConsistencyAlert(result);
}
return result;
}
/**
* 将一致性告警写入 GitHub 问题索引
* @param {object} alertResult
*/
function writeConsistencyAlert(alertResult) {
try {
let index = { issues: [] };
if (fs.existsSync(ISSUES_INDEX_PATH)) {
index = JSON.parse(fs.readFileSync(ISSUES_INDEX_PATH, 'utf8'));
}
// 避免重复写入同一类型告警（保留最近 20 条）
index.issues = index.issues.filter(i => i.type !== 'BRAIN_SPLIT_ALERT').slice(0, 19);
index.issues.unshift({
id: `BS-SPLIT-${Date.now()}`,
type: 'BRAIN_SPLIT_ALERT',
title: alertResult.alert,
detail: alertResult.alert_detail,
mismatches: alertResult.mismatches,
created_at: alertResult.checked_at,
status: 'open',
});
fs.writeFileSync(ISSUES_INDEX_PATH, JSON.stringify(index, null, 2));
} catch {
// 写入失败不影响主流程
}
}
// ══════════════════════════════════════════════════════════
// 人类开发者编号系统 (EXP-XXX)
// ══════════════════════════════════════════════════════════
/**
* 加载人类开发者注册表
* @returns {object}
*/
function loadHumanRegistry() {
try {
if (!fs.existsSync(HUMAN_REGISTRY_PATH)) return { developers: [], next_id: 1, pending_notifications: [] };
return JSON.parse(fs.readFileSync(HUMAN_REGISTRY_PATH, 'utf8'));
} catch {
return { developers: [], next_id: 1, pending_notifications: [] };
}
}
/**
* 保存人类开发者注册表
* @param {object} registry
*/
function saveHumanRegistry(registry) {
registry.last_updated = new Date().toISOString();
fs.writeFileSync(HUMAN_REGISTRY_PATH, JSON.stringify(registry, null, 2));
}
/**
* 获取开发者列表
* @returns {Array}
*/
function listDevelopers() {
const reg = loadHumanRegistry();
return reg.developers || [];
}
/**
* 根据 EXP ID 查找开发者
* @param {string} expId
* @returns {object|null}
*/
function findDeveloper(expId) {
const devs = listDevelopers();
return devs.find(d => d.exp_id === expId) || null;
}
/**
* 注册新的人类开发者（自动去重）
* @param {object} info — { name, github_username, role, notes, notify_channel }
* @returns {object} 注册结果，包含分配的 EXP ID
*/
function registerDeveloper(info) {
const registry = loadHumanRegistry();
const devs = registry.developers || [];
// 去重检查：按 name 或 github_username 去重
const existing = devs.find(d =>
(info.name && d.name === info.name) ||
(info.github_username && d.github_username && d.github_username === info.github_username)
);
if (existing) {
return { duplicate: true, existing: existing };
}
// 使用 next_id 或计算最大值
const nextNum = registry.next_id || (devs.reduce((max, d) => {
const num = parseInt(d.exp_id.replace('EXP-', ''), 10);
return isNaN(num) ? max : Math.max(max, num);
}, 0) + 1);
const nextId = `EXP-${String(nextNum).padStart(3, '0')}`;
const now = new Date().toISOString();
const newDev = {
exp_id: nextId,
name: info.name,
github_username: info.github_username || '',
role: info.role || 'developer',
status: 'active',
created_at: now,
notified: false,
notified_at: null,
notify_channel: info.notify_channel || 'pending',
notes: info.notes || '',
last_updated: now,
};
registry.developers.push(newDev);
registry.next_id = nextNum + 1;
// 自动加入待发送通知队列
if (!registry.pending_notifications) registry.pending_notifications = [];
registry.pending_notifications.push({
exp_id: nextId,
status: 'pending',
created_at: now,
});
saveHumanRegistry(registry);
return { duplicate: false, developer: newDev };
}
/**
* 生成开发者通知内容
* @param {string} expId
* @returns {object} { exp_id, name, notification }
*/
function generateDeveloperNotification(expId) {
const dev = findDeveloper(expId);
if (!dev) {
return { error: true, message: `开发者 ${expId} 不存在` };
}
return {
exp_id: dev.exp_id,
name: dev.name,
notification: NOTIFICATION_TEMPLATE.replace('{exp_id}', dev.exp_id),
notified: dev.notified,
notify_channel: dev.notify_channel,
};
}
/**
* 获取待发送通知队列
* @returns {Array}
*/
function getPendingNotifications() {
const registry = loadHumanRegistry();
return (registry.pending_notifications || []).filter(n => n.status === 'pending');
}
/**
* 标记通知已发送
* @param {string} expId
* @returns {boolean}
*/
function markNotified(expId) {
const registry = loadHumanRegistry();
const now = new Date().toISOString();
const dev = (registry.developers || []).find(d => d.exp_id === expId);
if (dev) {
dev.notified = true;
dev.notified_at = now;
dev.last_updated = now;
}
const pending = (registry.pending_notifications || []).find(n => n.exp_id === expId);
if (pending) {
pending.status = 'sent';
pending.sent_at = now;
}
saveHumanRegistry(registry);
return !!dev;
}
// ══════════════════════════════════════════════════════════
// 自动 Agent 调度体系
// ══════════════════════════════════════════════════════════
/**
* 获取已注册的自动 Agent 列表
* @returns {Array}
*/
function listAutoAgents() {
const state = loadBridgeState();
return (state && state.auto_agents) || [];
}
/**
* 生成巡检报告
* @returns {object}
*/
function generateInspectionReport() {
const sync = getSyncSnapshot();
const runtime = collectRuntimeStatus();
const registry = loadHumanRegistry();
const devs = registry.developers || [];
const unnotified = devs.filter(d => !d.notified && d.exp_id !== 'EXP-000');
return {
report_type: 'daily_inspection',
generated_at: new Date().toISOString(),
brain_bridge: {
status: 'operational',
brain_version: sync.brain_version,
master_mode: sync.master_mode,
last_updated: sync.last_updated,
},
runtime_status: runtime,
developer_registry: {
total: devs.length,
active: devs.filter(d => d.status === 'active').length,
unnotified: unnotified.length,
},
top_priorities: sync.top_priorities,
top_issues: sync.top_issues,
checks: {
brain_bridge_file: fs.existsSync(BRIDGE_STATE_PATH) ? 'ok' : 'missing',
human_registry_file: fs.existsSync(HUMAN_REGISTRY_PATH) ? 'ok' : 'missing',
system_health_file: fs.existsSync(SYSTEM_HEALTH_PATH) ? 'ok' : 'missing',
issues_index_file: fs.existsSync(ISSUES_INDEX_PATH) ? 'ok' : 'missing',
},
};
}
// ══════════════════════════════════════════════════════════
// 主控解释层（人类可理解语言输出）
// ══════════════════════════════════════════════════════════
/**
* 生成主控解释中心内容（人类语言摘要）
* @returns {object}
*/
function generateExplanationCenter() {
const sync = getSyncSnapshot();
const mode = getMasterMode();
const runtime = collectRuntimeStatus();
const statusMap = { green: '正常', yellow: '需关注', red: '异常', unknown: '未知' };
return {
title: '冰朔主控解释中心',
generated_at: new Date().toISOString(),
current_status: `系统当前由${mode.master}主控，模式为${mode.mode === 'HUMAN_CONTROL' ? '人类主控' : '自动运行'}。`,
system_summary: sync.system_summary || '系统运行中',
recent_changes: '冰朔核心大脑双层互通系统 v1.0 已建立，GitHub 执行层与 Notion 认知层互通桥接已配置。',
current_issues: (sync.top_issues || []).map((issue, i) => `${i + 1}. ${issue}`).join('\n') || '暂无重大问题',
next_steps: (sync.top_priorities || []).map((p, i) => `${i + 1}. ${p}`).join('\n') || '继续推进系统建设',
runtime_in_human_language: Object.entries(runtime).map(
([k, v]) => `${k}: ${statusMap[v] || v}`
).join('、'),
};
}
// ══════════════════════════════════════════════════════════
// 运行时状态收集（GitHub 执行层）
// ══════════════════════════════════════════════════════════
/**
* 收集 GitHub 执行层运行时状态
* @returns {object}
*/
function collectRuntimeStatus() {
const status = {
persona_studio: 'unknown',
deployment: 'unknown',
workflows: 'unknown',
api_routes: 'unknown',
};
// 检查系统健康文件
try {
if (fs.existsSync(SYSTEM_HEALTH_PATH)) {
const health = JSON.parse(fs.readFileSync(SYSTEM_HEALTH_PATH, 'utf8'));
const h = health.health || {};
status.deployment = h.deployment_health?.status || 'unknown';
status.workflows = h.workflow_health?.status || 'unknown';
status.persona_studio = h.persona_studio_health?.status || 'unknown';
status.api_routes = h.routing_health?.status || 'unknown';
}
} catch {
// 文件读取失败，保持 unknown
}
return status;
}
/**
* 生成 GitHub → Notion 同步负载
* @returns {object}
*/
function generateGitHubToNotionPayload() {
const sync = getSyncSnapshot();
const runtime = collectRuntimeStatus();
return {
brain_identity: sync.brain_identity,
brain_version: sync.brain_version,
master_mode: sync.master_mode,
runtime_status: runtime,
top_issues: sync.top_issues,
system_summary: sync.system_summary,
generated_at: new Date().toISOString(),
direction: 'GitHub→Notion',
};
}
/**
* 接收 Notion → GitHub 同步负载并更新本地状态
* @param {object} payload — Notion 发来的同步数据
* @returns {object} 更新结果
*/
function receiveNotionToGitHubPayload(payload) {
const updates = {};
const allowedFields = [
'master_mode',
'top_priorities',
'top_issues',
'human_status_summary',
'system_summary',
];
for (const field of allowedFields) {
if (payload[field] !== undefined) {
updates[field] = payload[field];
}
}
if (Object.keys(updates).length === 0) {
return { updated: false, message: '无可更新字段' };
}
const newState = updateSyncState(updates);
return {
updated: true,
fields_updated: Object.keys(updates),
sync_state: newState,
};
}
// ══════════════════════════════════════════════════════════
// 导出
// ══════════════════════════════════════════════════════════
module.exports = {
// 常量
MASTER_MODES,
SYNC_FIELDS,
NOTIFICATION_TEMPLATE,
// 桥接状态
loadBridgeState,
getSyncSnapshot,
updateSyncState,
// 主控模式
getMasterMode,
setMasterMode,
// 一致性检查
checkConsistency,
// 人类开发者编号
loadHumanRegistry,
listDevelopers,
findDeveloper,
registerDeveloper,
generateDeveloperNotification,
getPendingNotifications,
markNotified,
// 自动 Agent
listAutoAgents,
generateInspectionReport,
// 主控解释层
generateExplanationCenter,
// 运行时状态
collectRuntimeStatus,
generateGitHubToNotionPayload,
receiveNotionToGitHubPayload,
};

5
src/brain/index.js
View File

@ -8,6 +8,7 @@
// model-router — 任务型模型路由
// context-trimmer — 上下文滑动窗口裁剪
// memory-manager — 三层记忆管理
// brain-bridge — 冰朔核心大脑桥（双层互通系统）
'use strict';
@ -16,6 +17,7 @@ const { detectMode, MODES } = require('./mode-detector');
const { selectModel, recordFailure, getRoutingTable, getFailureStatus } = require('./model-router');
const { trimMessages, estimateTokens, CONTEXT_CONFIG } = require('./context-trimmer');
const { generateCandidates, getMemoryStatus, loadLongTermMemory, setTaskMemory, getTaskMemory } = require('./memory-manager');
const bridge = require('./brain-bridge');
const BRAIN_VERSION = 'v3.0';
@ -48,4 +50,7 @@ module.exports = {
loadLongTermMemory,
setTaskMemory,
getTaskMemory,
// 冰朔核心大脑桥
bridge,
};

172
src/routes/hli/brain/index.js
View File

@ -131,4 +131,176 @@ router.get('/status', (req, res) => {
});
});
// ══════════════════════════════════════════════════════════
// 冰朔核心大脑桥接口 (Brain Bridge)
// ══════════════════════════════════════════════════════════
// GET /hli/brain/bridge — 冰朔大脑桥状态总览
router.get('/bridge', (req, res) => {
const bridge = brain.bridge;
res.json({
hli_id: 'HLI-BRAIN-010',
sync_state: bridge.getSyncSnapshot(),
master_mode: bridge.getMasterMode(),
runtime_status: bridge.collectRuntimeStatus(),
developers: bridge.listDevelopers(),
auto_agents: bridge.listAutoAgents(),
explanation: bridge.generateExplanationCenter(),
});
});
// POST /hli/brain/bridge/sync — 接收 Notion → GitHub 同步
router.post('/bridge/sync', (req, res) => {
const bridge = brain.bridge;
const result = bridge.receiveNotionToGitHubPayload(req.body);
res.json({
hli_id: 'HLI-BRAIN-011',
...result,
});
});
// GET /hli/brain/bridge/export — 生成 GitHub → Notion 同步负载
router.get('/bridge/export', (req, res) => {
const bridge = brain.bridge;
res.json({
hli_id: 'HLI-BRAIN-012',
...bridge.generateGitHubToNotionPayload(),
});
});
// POST /hli/brain/bridge/consistency — 版本一致性检查
router.post('/bridge/consistency', (req, res) => {
const bridge = brain.bridge;
const notionState = req.body;
if (!notionState || typeof notionState !== 'object') {
return res.status(400).json({
error: true,
code: 'MISSING_NOTION_STATE',
message: '缺少 Notion 侧同步状态',
});
}
const result = bridge.checkConsistency(notionState);
res.json({
hli_id: 'HLI-BRAIN-013',
...result,
});
});
// POST /hli/brain/bridge/master-mode — 切换主控模式
router.post('/bridge/master-mode', (req, res) => {
const bridge = brain.bridge;
const { mode } = req.body;
if (!mode) {
return res.status(400).json({
error: true,
code: 'MISSING_MODE',
message: '缺少 mode 参数，可选: HUMAN_CONTROL, AUTONOMOUS_MODE',
});
}
try {
const result = bridge.setMasterMode(mode);
res.json({
hli_id: 'HLI-BRAIN-014',
...result,
});
} catch (err) {
res.status(400).json({
error: true,
code: 'INVALID_MODE',
message: err.message,
});
}
});
// GET /hli/brain/bridge/explanation — 主控解释中心
router.get('/bridge/explanation', (req, res) => {
const bridge = brain.bridge;
res.json({
hli_id: 'HLI-BRAIN-015',
...bridge.generateExplanationCenter(),
});
});
// GET /hli/brain/bridge/inspection — 巡检报告
router.get('/bridge/inspection', (req, res) => {
const bridge = brain.bridge;
res.json({
hli_id: 'HLI-BRAIN-016',
...bridge.generateInspectionReport(),
});
});
// GET /hli/brain/bridge/developers — 人类开发者编号列表
router.get('/bridge/developers', (req, res) => {
const bridge = brain.bridge;
res.json({
hli_id: 'HLI-BRAIN-017',
developers: bridge.listDevelopers(),
pending_notifications: bridge.getPendingNotifications(),
});
});
// GET /hli/brain/bridge/developers/:expId — 查询单个开发者
router.get('/bridge/developers/:expId', (req, res) => {
const bridge = brain.bridge;
const dev = bridge.findDeveloper(req.params.expId);
if (!dev) {
return res.status(404).json({
error: true,
code: 'DEVELOPER_NOT_FOUND',
message: `开发者 ${req.params.expId} 不存在`,
});
}
const notification = bridge.generateDeveloperNotification(req.params.expId);
res.json({
hli_id: 'HLI-BRAIN-018',
developer: dev,
notification: notification.notification,
});
});
// POST /hli/brain/bridge/developers — 注册新开发者
router.post('/bridge/developers', (req, res) => {
const bridge = brain.bridge;
const { name } = req.body;
if (!name) {
return res.status(400).json({
error: true,
code: 'MISSING_NAME',
message: '缺少 name 参数',
});
}
const result = bridge.registerDeveloper(req.body);
if (result.duplicate) {
return res.status(409).json({
error: true,
code: 'DUPLICATE_DEVELOPER',
message: `开发者已存在: ${result.existing.exp_id} (${result.existing.name})`,
existing: result.existing,
});
}
res.status(201).json({
hli_id: 'HLI-BRAIN-019',
...result,
});
});
module.exports = router;

27
src/schemas/hli/brain/bridge.schema.json Normal file
View File

@ -0,0 +1,27 @@
{
"hli_id": "HLI-BRAIN-010",
"version": "v1.0",
"route": "/hli/brain/bridge",
"method": "GET",
"type": "REQUEST",
"description": "获取冰朔大脑桥当前同步状态、主控模式、运行时状态与人类开发者编号列表。",
"input": {
"type": "object",
"required": [],
"properties": {}
},
"output": {
"type": "object",
"required": ["hli_id", "sync_state", "master_mode", "runtime_status"],
"properties": {
"hli_id": { "type": "string" },
"sync_state": { "type": "object", "description": "当前统一同步字段快照" },
"master_mode": { "type": "object", "description": "当前主控模式信息" },
"runtime_status": { "type": "object", "description": "GitHub 执行层运行时状态" },
"developers": { "type": "array", "description": "人类开发者编号列表" }
}
},
"changelog": [
{ "date": "2026-03-10", "note": "冰朔核心大脑双层互通系统 v1.0 — 建立大脑桥" }
]
}