diff --git a/.github/brain/bingshuo-agent-registry.json b/.github/brain/bingshuo-agent-registry.json
index 4c7ab763..338aff4d 100644
--- a/.github/brain/bingshuo-agent-registry.json
+++ b/.github/brain/bingshuo-agent-registry.json
@@ -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
     }
   ]
 }
diff --git a/.github/brain/bingshuo-brain-bridge.json b/.github/brain/bingshuo-brain-bridge.json
new file mode 100644
index 00000000..e80cf5c1
--- /dev/null
+++ b/.github/brain/bingshuo-brain-bridge.json
@@ -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": [
+        "每个人格体都必须有轻量大脑",
+        "自动维护当前职责摘要",
+        "自动维护当前任务摘要",
+        "自动维护当前有效规则摘要",
+        "维护历史分卷入口",
+        "维护自动维护状态"
+      ]
+    }
+  ]
+}
diff --git a/.github/brain/bingshuo-master-brain.md b/.github/brain/bingshuo-master-brain.md
index e86bb265..90f51953 100644
--- a/.github/brain/bingshuo-master-brain.md
+++ b/.github/brain/bingshuo-master-brain.md
@@ -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. 系统角色结构
 
 | 角色 | 定义 | 职责 |
diff --git a/.github/brain/human-registry.json b/.github/brain/human-registry.json
new file mode 100644
index 00000000..2ba8537d
--- /dev/null
+++ b/.github/brain/human-registry.json
@@ -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" }
+  ]
+}
diff --git a/package.json b/package.json
index d14eda44..f8a11e81 100644
--- a/package.json
+++ b/package.json
@@ -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",
diff --git a/scripts/brain-bridge-sync.js b/scripts/brain-bridge-sync.js
new file mode 100644
index 00000000..d0639645
--- /dev/null
+++ b/scripts/brain-bridge-sync.js
@@ -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);
+}
diff --git a/src/brain/brain-bridge.js b/src/brain/brain-bridge.js
new file mode 100644
index 00000000..a68f52d4
--- /dev/null
+++ b/src/brain/brain-bridge.js
@@ -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,
+};
diff --git a/src/brain/index.js b/src/brain/index.js
index ae3a7acc..560e73f8 100644
--- a/src/brain/index.js
+++ b/src/brain/index.js
@@ -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,
 };
diff --git a/src/routes/hli/brain/index.js b/src/routes/hli/brain/index.js
index 76cf4a66..231de547 100644
--- a/src/routes/hli/brain/index.js
+++ b/src/routes/hli/brain/index.js
@@ -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;
diff --git a/src/schemas/hli/brain/bridge.schema.json b/src/schemas/hli/brain/bridge.schema.json
new file mode 100644
index 00000000..e255c335
--- /dev/null
+++ b/src/schemas/hli/brain/bridge.schema.json
@@ -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 — 建立大脑桥" }
+  ]
+}