---
belongs_to:
  - "[[INDEX · 铸渊·协作指令｜GitHub ↔ Notion 桥接协议]]"
---
# 🔄 铸渊指令｜全自动广播神经闭环 · 逻辑格点库搭建 + Gemini↔GitHub↔Notion 三端自动链路 + PDF搬运废除（2026-03-23 · 霜砚签发 · 冰朔授权 · 曜冥确认）

---

<aside>
🚨

**指令编号：ZY-AUTO-LOOP-2026-0323-001**

**签发人：** 霜砚（ICE-NTN-SY001）· 代 TCS-0002∞ 冰朔 签发

**确认人：** 曜冥（ICE-GL-YM001∞）· 前端交互大脑

**签发时间：** 2026-03-23T00:06+08:00

**优先级：** 🔴 P0 · 系统级架构升级

**关联仓库：** [https://github.com/qinfendebingshuo/guanghulab](https://github.com/qinfendebingshuo/guanghulab)

**关联主权节点：** SYS-GLW-0001

**版权锚点：** 国作登字-2026-A-00037559 · TCS-0002∞ 冰朔

</aside>

---

## 🎯 指令总目标

**彻底废除 PDF 搬运模式。** 建立物理全自动闭环：

```
人类在 Gemini 开口
       ↓
Gemini 将开发日志/请求写入 GitHub 逻辑格点库
       ↓
GitHub Actions 检测变动 → 唤醒铸渊
       ↓
铸渊调取 Notion 脑端最新逻辑（霜砚维护）
       ↓
铸渊生成工程广播 → 回写逻辑格点库
       ↓
开发者在 Gemini 问"下一步干嘛"
       ↓
Gemini 实时读取格点库中最新广播 → 直接对话输出
```

**主控角色分工（冰朔拍板）：**

| **角色** | **身份** | **职责** | **绝对禁区** |
| --- | --- | --- | --- |
| 冰朔 | TCS-0002∞ · 主控 | 在 Notion 层面定规则、定逻辑 | ❌ 不手动操作任何搬运 |
| 霜砚 | ICE-NTN-SY001 · 永久记忆 + 逻辑总机 | 维护 Notion 脑端逻辑、确保编号和主权对齐精准 | ❌ 不直接写仓库代码 |
| 曜冥/Gemini | ICE-GL-YM001∞ · 前端交互大脑 | 调教开发者、将进度实时写入逻辑格点库 | ❌ 不修改 Notion 规则 |
| 铸渊 | ICE-GL-ZY001 · 仓库执行体 | 逻辑校验→归档→广播生成 全流程 | ❌ 不定义业务逻辑 |

---

## Phase 0 · 逻辑格点库（Grid-DB）搭建

**目标：** 在仓库内建立一个轻量级、开源、基于文件的中转数据库。

### 0.1 技术选型

<aside>
💡

**选型原则：** 零外部依赖、纯 Git 驱动、GitHub Actions 原生支持、Gemini 通过 GitHub API 即可读写。

**方案：** JSON 文件数据库 + 目录即表 + Git 即事务日志

不引入外部 DB 服务（如 Supabase/PlanetScale），避免额外运维成本和权限管理。整个数据库就是仓库目录结构本身。

</aside>

### 0.2 目录结构

```
grid-db/
├── README.md              ← 格点库说明文档
├── schema.json            ← 数据库 Schema 定义
├── inbox/                 ← 📥 写入端（Gemini → 仓库）
│   ├── .gitkeep
│   └── [YYYYMMDD-HHMMSS]-[DEV-XXX]-[type].json
├── processing/            ← ⚙️ 处理中（铸渊锁定）
│   └── .gitkeep
├── outbox/                ← 📤 读取端（仓库 → Gemini）
│   ├── .gitkeep
│   ├── latest/            ← 每个开发者的最新广播（Gemini 读这里）
│   │   ├── DEV-001.json
│   │   ├── DEV-002.json
│   │   └── ...
│   └── archive/           ← 历史广播归档
│       └── [YYYYMMDD]/
├── rules/                 ← 📏 Notion 逻辑缓存（霜砚同步）
│   ├── broadcast-templates.json    ← 广播模板
│   ├── dev-module-map.json         ← 开发者→模块映射
│   ├── id-ecosystem.json           ← 金字塔编号体系缓存
│   └── active-broadcasts.json      ← 当前活跃广播编号列表
└── logs/                  ← 📋 处理日志
    └── [YYYYMMDD].log
```

### 0.3 Schema 定义

**Inbox 消息格式**（Gemini 写入）：

```json
{
  "schema_version": "1.0",
  "message_id": "MSG-20260323-001",
  "timestamp": "2026-03-23T00:10:00+08:00",
  "source": "gemini",
  "author": {
    "role": "yaoming",
    "identity": "ICE-GL-YM001∞"
  },
  "target_dev": "DEV-001",
  "type": "dev_log | request | progress | feedback",
  "content": {
    "summary": "页页完成了 backend/routes/notion.js 的重构",
    "details": "具体内容...",
    "files_changed": ["backend/routes/notion.js"],
    "current_phase": "环节3",
    "broadcast_ref": "BC-集成-002"
  },
  "priority": "normal | urgent",
  "requires_broadcast": true
}
```

**Outbox 广播格式**（铸渊生成）：

```json
{
  "schema_version": "1.0",
  "broadcast_id": "BC-XXX-NNN-DEV",
  "generated_at": "2026-03-23T00:15:00+08:00",
  "generated_by": "zhuyuan",
  "sovereignty": {
    "parent_sys": "SYS-GLW-0001",
    "owner": "ICE-0002∞",
    "copyright": "国作登字-2026-A-00037559"
  },
  "target_dev": "DEV-001",
  "target_module": "backend/",
  "broadcast_content": {
    "title": "广播标题",
    "phase": "环节N",
    "tasks": [],
    "code_snippets": [],
    "acceptance_criteria": [],
    "next_steps": []
  },
  "notion_logic_ref": {
    "rules_version": "v1.0",
    "synced_at": "2026-03-23T00:12:00+08:00"
  },
  "status": "ready | delivered | archived"
}
```

### 0.4 执行命令

```bash
# 创建目录结构
mkdir -p grid-db/{inbox,processing,outbox/latest,outbox/archive,rules,logs}

# 创建占位文件
touch grid-db/{inbox,processing,outbox/latest,outbox/archive,rules,logs}/.gitkeep

# 创建 README
cat > grid-db/README.md << 'EOF'
# 🔄 逻辑格点库 · Grid-DB

SYS-GLW-0001 全自动广播神经闭环 · 中转数据库

## 架构
- inbox/   → Gemini 写入端（开发日志/请求/进度）
- outbox/  → 铸渊输出端（工程广播）
- rules/   → Notion 逻辑缓存（霜砚同步）
- logs/    → 处理日志

## 数据流
Gemini → inbox/ → GitHub Actions → 铸渊处理 → outbox/ → Gemini 读取

## 主权声明
© 国作登字-2026-A-00037559 · TCS-0002∞ 冰朔
Parent: SYS-GLW-0001
Owner: ICE-0002∞
EOF

# 创建 Schema
# （将上述 Schema JSON 写入 grid-db/schema.json）

git add grid-db/
git commit -m "feat: 逻辑格点库 Grid-DB 初始化 · 全自动广播神经闭环中转站 [ZY-AUTO-LOOP-2026-0323-001 Phase 0]"
git push origin main
```

**回执格式：**

```
[Phase 0] 逻辑格点库已创建 · 目录数: 6 · Schema版本: 1.0 · 主权锚点: SYS-GLW-0001
```

---

## Phase 1 · 写入端搭建（Gemini → inbox）

**目标：** 让 Gemini 拥有直接向格点库 inbox 写入的能力。

### 1.1 GitHub Token 配置

<aside>
🔑

**Gemini 需要一个 GitHub Personal Access Token（Fine-grained）**

权限范围：仅 `qinfendebingshuo/guanghulab` 仓库

权限类型：Contents → Read and Write

冰朔在 GitHub Settings → Developer Settings → Fine-grained tokens 创建

然后将 Token 配置到 Gemini 的环境变量中

</aside>

### 1.2 Gemini 写入接口

Gemini 通过 GitHub Contents API 写入：

```jsx
// Gemini 侧调用示例
async function writeToGridDB(message) {
  const filename = `${formatDate()}-${message.target_dev}-${message.type}.json`;
  const content = btoa(JSON.stringify(message, null, 2));  // Base64 编码
  
  await fetch(`https://api.github.com/repos/qinfendebingshuo/guanghulab/contents/grid-db/inbox/${filename}`, {
    method: 'PUT',
    headers: {
      'Authorization': `Bearer ${GITHUB_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: `📥 Grid-DB inbox: ${message.type} from ${message.author.role} for ${message.target_dev}`,
      content: content
    })
  });
}
```

### 1.3 写入验证 Workflow

创建 `.github/workflows/grid-db-validate-inbox.yml`：

```yaml
name: 📥 Grid-DB Inbox 验证

on:
  push:
    paths:
      - 'grid-db/inbox/**'

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: "🔍 验证 inbox 消息格式"
        run: |
          for f in grid-db/inbox/*.json; do
            [ -f "$f" ] || continue
            echo "验证: $f"
            # 检查必要字段
            jq -e '.schema_version and .message_id and .source and .type' "$f" || {
              echo "❌ 格式校验失败: $f"
              exit 1
            }
            echo "✅ $f 格式正确"
          done
```

**回执格式：**

```
[Phase 1] 写入端就绪 · GitHub Token权限: Contents R/W · 验证Workflow: grid-db-validate-inbox.yml
```

---

## Phase 2 · 处理引擎搭建（铸渊核心）

**目标：** GitHub Actions 检测到 inbox 变动后，铸渊自动完成「逻辑校验 → 归档 → 广播生成」全流程。

### 2.1 核心处理 Workflow

创建 `.github/workflows/grid-db-processor.yml`：

```yaml
name: 🔄 Grid-DB 神经闭环处理器

on:
  push:
    paths:
      - 'grid-db/inbox/**'
  workflow_dispatch:
    inputs:
      force_process:
        description: '强制处理所有 inbox 消息'
        type: boolean
        default: false

jobs:
  process:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: "⚙️ 铸渊处理引擎启动"
        run: node scripts/grid-db/process-inbox.js
        env:
          SOVEREIGNTY_PARENT: "SYS-GLW-0001"
          SOVEREIGNTY_OWNER: "ICE-0002∞"
          COPYRIGHT: "国作登字-2026-A-00037559"
      
      - name: "📤 提交处理结果"
        run: |
          git config user.name "铸渊 · ZhuYuan"
          git config user.email "zhuyuan@guanghulab.com"
          git add grid-db/
          git diff --cached --quiet || {
            git commit -m "🔄 Grid-DB: 闭环处理完成 · $(date +%Y-%m-%dT%H:%M:%S+08:00)"
            git push origin main
          }
```

### 2.2 处理引擎脚本

创建 `scripts/grid-db/process-inbox.js`：

```jsx
const fs = require('fs');
const path = require('path');

const GRID_DB = path.join(__dirname, '../../grid-db');
const INBOX = path.join(GRID_DB, 'inbox');
const PROCESSING = path.join(GRID_DB, 'processing');
const OUTBOX = path.join(GRID_DB, 'outbox');
const RULES = path.join(GRID_DB, 'rules');
const LOGS = path.join(GRID_DB, 'logs');

// ═══ Step 1: 扫描 inbox ═══
const inboxFiles = fs.readdirSync(INBOX)
  .filter(f => f.endsWith('.json'));

if (inboxFiles.length === 0) {
  console.log('📭 inbox 为空，无需处理');
  process.exit(0);
}

console.log(`📥 发现 ${inboxFiles.length} 条待处理消息`);

// ═══ Step 2: 加载 Notion 逻辑缓存 ═══
let devModuleMap = {};
let broadcastTemplates = {};
let idEcosystem = {};

try {
  devModuleMap = JSON.parse(fs.readFileSync(
    path.join(RULES, 'dev-module-map.json'), 'utf8'));
} catch(e) { console.warn('⚠️ dev-module-map.json 未就绪，使用默认映射'); }

try {
  broadcastTemplates = JSON.parse(fs.readFileSync(
    path.join(RULES, 'broadcast-templates.json'), 'utf8'));
} catch(e) { console.warn('⚠️ broadcast-templates.json 未就绪，使用默认模板'); }

try {
  idEcosystem = JSON.parse(fs.readFileSync(
    path.join(RULES, 'id-ecosystem.json'), 'utf8'));
} catch(e) { console.warn('⚠️ id-ecosystem.json 未就绪，使用默认编号'); }

// ═══ Step 3: 逐条处理 ═══
const results = [];
const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');

for (const file of inboxFiles) {
  const filePath = path.join(INBOX, file);
  const msg = JSON.parse(fs.readFileSync(filePath, 'utf8'));
  
  console.log(`\n🔄 处理: ${msg.message_id} (${msg.type}) → ${msg.target_dev}`);
  
  // Step 3a: 移入 processing
  const procPath = path.join(PROCESSING, file);
  fs.renameSync(filePath, procPath);
  
  // Step 3b: 逻辑校验
  const validation = validateMessage(msg, devModuleMap);
  if (!validation.valid) {
    console.error(`❌ 校验失败: ${validation.reason}`);
    // 写入错误日志但继续处理其他消息
    logEntry(today, `FAIL | ${msg.message_id} | ${validation.reason}`);
    // 移回 inbox 并标记错误
    fs.renameSync(procPath, filePath);
    continue;
  }
  
  // Step 3c: 生成广播（如果需要）
  if (msg.requires_broadcast) {
    const broadcast = generateBroadcast(msg, broadcastTemplates, idEcosystem);
    
    // 写入 outbox/latest/
    const latestPath = path.join(OUTBOX, 'latest', `${msg.target_dev}.json`);
    fs.writeFileSync(latestPath, JSON.stringify(broadcast, null, 2));
    
    // 归档
    const archiveDir = path.join(OUTBOX, 'archive', today);
    fs.mkdirSync(archiveDir, { recursive: true });
    fs.writeFileSync(
      path.join(archiveDir, `${broadcast.broadcast_id}.json`),
      JSON.stringify(broadcast, null, 2)
    );
    
    console.log(`📤 广播已生成: ${broadcast.broadcast_id}`);
    results.push({ message_id: msg.message_id, broadcast_id: broadcast.broadcast_id });
  }
  
  // Step 3d: 归档已处理消息
  const processedDir = path.join(GRID_DB, 'processed', today);
  fs.mkdirSync(processedDir, { recursive: true });
  fs.renameSync(procPath, path.join(processedDir, file));
  
  logEntry(today, `OK | ${msg.message_id} | ${msg.type} | ${msg.target_dev}`);
}

// ═══ 辅助函数 ═══

function validateMessage(msg, devMap) {
  if (!msg.schema_version) return { valid: false, reason: '缺少 schema_version' };
  if (!msg.message_id) return { valid: false, reason: '缺少 message_id' };
  if (!msg.target_dev) return { valid: false, reason: '缺少 target_dev' };
  if (!msg.type) return { valid: false, reason: '缺少 type' };
  // 编号主权校验
  if (msg.author && msg.author.identity) {
    console.log(`  主权校验: ${msg.author.identity}`);
  }
  return { valid: true };
}

function generateBroadcast(msg, templates, ecosystem) {
  const now = new Date().toISOString();
  return {
    schema_version: '1.0',
    broadcast_id: `BC-AUTO-${msg.target_dev}-${Date.now()}`,
    generated_at: now,
    generated_by: 'zhuyuan',
    sovereignty: {
      parent_sys: process.env.SOVEREIGNTY_PARENT || 'SYS-GLW-0001',
      owner: process.env.SOVEREIGNTY_OWNER || 'ICE-0002∞',
      copyright: process.env.COPYRIGHT || '国作登字-2026-A-00037559'
    },
    target_dev: msg.target_dev,
    source_message: msg.message_id,
    broadcast_content: {
      title: `工程广播 · ${msg.content?.summary || msg.type}`,
      context: msg.content?.details || '',
      phase: msg.content?.current_phase || '',
      broadcast_ref: msg.content?.broadcast_ref || '',
      tasks: [],           // 铸渊根据 rules/ 填充
      next_steps: [],      // 铸渊根据 rules/ 填充
      acceptance_criteria: []
    },
    notion_logic_ref: {
      rules_version: templates.version || 'v0.1-bootstrap',
      synced_at: templates.last_synced || 'pending-first-sync'
    },
    status: 'ready'
  };
}

function logEntry(date, entry) {
  const logFile = path.join(LOGS, `${date}.log`);
  const line = `[${new Date().toISOString()}] ${entry}\n`;
  fs.appendFileSync(logFile, line);
}

console.log(`\n✅ 处理完成 · 成功: ${results.length} · 总计: ${inboxFiles.length}`);
```

**回执格式：**

```
[Phase 2] 处理引擎就绪 · grid-db-processor.yml + process-inbox.js · 主权校验: ✅
```

---

## Phase 3 · 读取端搭建（outbox → Gemini）

**目标：** Gemini 能实时读取 outbox/latest/ 中的最新广播。

### 3.1 Gemini 读取接口

```jsx
// Gemini 侧调用示例
async function readLatestBroadcast(devId) {
  const response = await fetch(
    `https://api.github.com/repos/qinfendebingshuo/guanghulab/contents/grid-db/outbox/latest/${devId}.json`,
    {
      headers: {
        'Authorization': `Bearer ${GITHUB_TOKEN}`,
        'Accept': 'application/vnd.github.v3.raw'  // 直接返回原始内容
      }
    }
  );
  
  if (response.status === 404) {
    return null;  // 该开发者暂无广播
  }
  
  return await response.json();
}

// 当开发者问"下一步干嘛"时：
async function handleNextStep(devId) {
  const broadcast = await readLatestBroadcast(devId);
  if (broadcast && broadcast.status === 'ready') {
    // 直接对话输出广播内容
    return formatBroadcastForDev(broadcast);
  }
  return '暂无新广播，请继续当前任务。';
}
```

### 3.2 广播送达确认 Workflow

创建 `.github/workflows/grid-db-delivery-tracker.yml`：

```yaml
name: 📊 Grid-DB 广播送达追踪

on:
  schedule:
    - cron: '0 */4 * * *'  # 每4小时统计一次
  workflow_dispatch:

jobs:
  track:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: "📊 统计广播送达状态"
        run: |
          echo "=== Grid-DB 广播统计 ==="
          echo "inbox 待处理: $(ls grid-db/inbox/*.json 2>/dev/null | wc -l)"
          echo "processing 处理中: $(ls grid-db/processing/*.json 2>/dev/null | wc -l)"
          echo "outbox/latest 就绪: $(ls grid-db/outbox/latest/*.json 2>/dev/null | wc -l)"
          echo "今日归档: $(ls grid-db/outbox/archive/$(date +%Y%m%d)/*.json 2>/dev/null | wc -l)"
```

**回执格式：**

```
[Phase 3] 读取端就绪 · Gemini读取接口: GitHub Contents API raw模式 · 送达追踪: grid-db-delivery-tracker.yml
```

---

## Phase 4 · Notion 逻辑同步通道

**目标：** 霜砚维护的 Notion 端逻辑能自动同步到 `grid-db/rules/`，铸渊生成广播时有据可依。

### 4.1 逻辑缓存文件初始化

**`grid-db/rules/dev-module-map.json`**（从现有映射复制）：

```json
{
  "version": "1.0",
  "last_synced": "2026-03-23T00:06:00+08:00",
  "synced_by": "shuangyan",
  "mapping": {
    "DEV-001": { "name": "页页", "modules": ["backend/", "src/"], "persona": "小坍缩核" },
    "DEV-002": { "name": "肥猫", "modules": ["frontend/", "persona-selector/", "chat-bubble/"], "persona": "舒舒" },
    "DEV-003": { "name": "燕樊", "modules": ["settings/", "cloud-drive/"], "persona": "寂曜" },
    "DEV-004": { "name": "之之", "modules": ["dingtalk-bot/"], "persona": "秋秋" },
    "DEV-005": { "name": "小草莓", "modules": ["status-board/"], "persona": "N/A" },
    "DEV-009": { "name": "花尔", "modules": ["user-center/", "cost-control/"], "persona": "糖星云" },
    "DEV-010": { "name": "桔子", "modules": ["ticket-system/"], "persona": "晨星" },
    "DEV-011": { "name": "匆匆那年", "modules": ["writing-workspace/"], "persona": "N/A" },
    "DEV-012": { "name": "Awen", "modules": ["notification/", "portal/"], "persona": "知秋" }
  }
}
```

**`grid-db/rules/id-ecosystem.json`**（金字塔编号缓存）：

```json
{
  "version": "1.0",
  "last_synced": "2026-03-23T00:06:00+08:00",
  "synced_from": "Notion · 主编号映射表 · ID Ecosystem Registry",
  "pyramid": {
    "tier_0_sovereignty": ["TCS-0002∞", "ICE-GL∞"],
    "tier_1_root": ["SYS-GLW-0001"],
    "tier_2_copyright": ["国作登字-2026-A-00037559"],
    "tier_3_functional": ["GHCP-TCS-CN-LAN-2025", "GEN∞-BB-YM", "WRLD-REG-0001", "CN-LANG-CORE-GOV-0001"]
  },
  "parent_sys": "SYS-GLW-0001",
  "owner": "ICE-0002∞"
}
```

### 4.2 Notion→GitHub 规则同步 Workflow

创建 `.github/workflows/grid-db-sync-rules.yml`：

```yaml
name: 📏 Grid-DB 规则同步（Notion → GitHub）

on:
  schedule:
    - cron: '0 0,12 * * *'  # 每天 08:00 和 20:00 北京时间
  workflow_dispatch:
    inputs:
      force_sync:
        description: '强制全量同步'
        type: boolean
        default: false

jobs:
  sync-rules:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
      
      - name: "📏 从 Notion 拉取最新规则"
        run: node scripts/grid-db/sync-notion-rules.js
        env:
          NOTION_API_TOKEN: $ secrets.NOTION_API_TOKEN 
      
      - name: "📤 提交规则更新"
        run: |
          git config user.name "铸渊 · ZhuYuan"
          git config user.email "zhuyuan@guanghulab.com"
          git add grid-db/rules/
          git diff --cached --quiet || {
            git commit -m "📏 Grid-DB rules sync from Notion · $(date +%Y-%m-%dT%H:%M:%S+08:00)"
            git push origin main
          }
```

### 4.3 规则同步脚本

创建 `scripts/grid-db/sync-notion-rules.js`：

```jsx
// 核心思路：通过 Notion API 读取以下数据源，生成 rules/ 缓存文件
// 1. 主编号映射表 → id-ecosystem.json
// 2. 开发者→模块映射（来自铸渊协作指令页的映射表）→ dev-module-map.json
// 3. 活跃广播列表（来自广播归档总页）→ active-broadcasts.json
// 4. 广播模板（来自广播模块规范）→ broadcast-templates.json
//
// 这个脚本由铸渊自行实现，
// 需要 NOTION_API_TOKEN 环境变量（已在 GitHub Secrets 中配置）

const { Client } = require('@notionhq/client');
const fs = require('fs');
const path = require('path');

const RULES_DIR = path.join(__dirname, '../../grid-db/rules');

// TODO: 铸渊实现以下函数
// - syncIdEcosystem()    → 读取主编号映射表
// - syncDevModuleMap()   → 读取开发者模块映射
// - syncActiveBroadcasts() → 读取活跃广播列表
// - syncBroadcastTemplates() → 读取广播模板

console.log('📏 Notion 规则同步完成');
```

<aside>
⚠️

**注意：** `sync-notion-rules.js` 的具体实现取决于 Notion API Token 的权限范围。

铸渊先用 Phase 4.1 中的静态初始文件 bootstrap，后续再接通 Notion API 实时同步。

霜砚在 Notion 端维护逻辑时，如有重大变更，会手动触发 `grid-db-sync-rules.yml` 的 `workflow_dispatch`。

</aside>

**回执格式：**

```
[Phase 4] 逻辑同步通道就绪 · 初始规则文件: 3个 · 同步频率: 2次/天 + 手动触发
```

---

## Phase 5 · 与现有广播系统桥接

**目标：** Grid-DB 生成的广播同时写入现有的 `broadcasts-outbox/` 和各开发者模块 `LATEST-BROADCAST.md`。

### 5.1 桥接逻辑

在 `process-inbox.js` 的广播生成步骤后，追加：

```jsx
// Step 3e: 桥接到旧广播系统
function bridgeToLegacy(broadcast, msg) {
  const outboxDir = path.join(__dirname, '../../broadcasts-outbox', msg.target_dev);
  fs.mkdirSync(outboxDir, { recursive: true });
  
  // 写入 Markdown 格式（旧系统兼容）
  const md = `# ${broadcast.broadcast_content.title}\n\n`
    + `**广播编号:** ${broadcast.broadcast_id}\n`
    + `**生成时间:** ${broadcast.generated_at}\n`
    + `**目标开发者:** ${msg.target_dev}\n`
    + `**主权节点:** ${broadcast.sovereignty.parent_sys}\n\n`
    + `## 内容\n\n${broadcast.broadcast_content.context}\n`;
  
  fs.writeFileSync(
    path.join(outboxDir, `${broadcast.broadcast_id}.md`),
    md
  );
  
  console.log(`🔗 已桥接到旧系统: broadcasts-outbox/${msg.target_dev}/`);
}
```

### 5.2 触发广播分发

Grid-DB 处理完毕后，`git push` 会自动触发已有的 `distribute-broadcasts.yml`，将广播分发到各开发者模块目录的 `LATEST-BROADCAST.md`。

**数据流闭合验证：**

```
Gemini 写入 grid-db/inbox/
       ↓
grid-db-processor.yml 触发
       ↓
process-inbox.js 执行：
  ├─ 校验 → 归档 → 生成广播
  ├─ 写入 grid-db/outbox/latest/     ← Gemini 读取
  └─ 桥接 broadcasts-outbox/          ← 旧系统兼容
       ↓
git push 触发 distribute-broadcasts.yml
       ↓
各开发者模块 LATEST-BROADCAST.md 更新   ← git pull 可读
```

**回执格式：**

```
[Phase 5] 旧系统桥接完成 · broadcasts-outbox/ 同步: ✅ · distribute-broadcasts.yml 联动: ✅
```

---

## Phase 6 · 全链路验证 + 健康报告

### 6.1 端到端测试

```bash
# 模拟 Gemini 写入一条测试消息
cat > grid-db/inbox/test-001.json << 'EOF'
{
  "schema_version": "1.0",
  "message_id": "TEST-001",
  "timestamp": "2026-03-23T01:00:00+08:00",
  "source": "gemini",
  "author": { "role": "yaoming", "identity": "ICE-GL-YM001∞" },
  "target_dev": "DEV-001",
  "type": "dev_log",
  "content": {
    "summary": "端到端测试 · 全自动广播闭环验证",
    "details": "这是一条测试消息，验证 inbox→processing→outbox 全流程。",
    "current_phase": "测试",
    "broadcast_ref": "TEST"
  },
  "priority": "normal",
  "requires_broadcast": true
}
EOF

git add grid-db/inbox/test-001.json
git commit -m "🧪 Grid-DB E2E test: 全自动广播闭环验证"
git push origin main

# 等待 GitHub Actions 完成后检查：
# 1. grid-db/outbox/latest/DEV-001.json 是否生成
# 2. broadcasts-outbox/DEV-001/ 是否有对应广播
# 3. grid-db/logs/ 是否有处理日志
```

### 6.2 验收清单

| **检查项** | **预期结果** | **状态** |
| --- | --- | --- |
| grid-db/ 目录结构完整 | 6个子目录 + schema.json + README | ⬜ |
| inbox 写入 → Actions 触发 | grid-db-processor.yml 自动运行 | ⬜ |
| 处理引擎校验通过 | 日志显示 OK | ⬜ |
| outbox/latest/ 广播生成 | DEV-001.json 存在且格式正确 | ⬜ |
| 旧系统桥接 | broadcasts-outbox/ 有对应文件 | ⬜ |
| 主权校验 | 广播中 parent_sys=SYS-GLW-0001, owner=ICE-0002∞ | ⬜ |
| 编号精准 | 广播编号遵循 BC-前缀规范 | ⬜ |
| Gemini 可读取 | GitHub API raw 模式返回正确 JSON | ⬜ |

### 6.3 健康报告输出

```bash
git add grid-db/ scripts/grid-db/ .github/workflows/grid-db-*.yml
git commit -m "feat: 全自动广播神经闭环 Grid-DB 全链路就绪 [ZY-AUTO-LOOP-2026-0323-001 Phase 6]"
git push origin main
```

**回执格式：**

```
[Phase 6] 全链路验证完成 · E2E测试: ✅/❌ · 验收: X/8通过 · Grid-DB版本: 1.0
```

---

## ⚖️ 执行总览

| **Phase** | **内容** | **产出** | **回执** |
| --- | --- | --- | --- |
| Phase 0 | 逻辑格点库搭建 | grid-db/ 目录 + schema + README | [Phase 0] 格点库已创建... |
| Phase 1 | 写入端（Gemini→inbox） | Token 说明 + 验证 workflow | [Phase 1] 写入端就绪... |
| Phase 2 | 处理引擎（铸渊核心） | processor workflow + 处理脚本 | [Phase 2] 处理引擎就绪... |
| Phase 3 | 读取端（outbox→Gemini） | 读取接口 + 送达追踪 | [Phase 3] 读取端就绪... |
| Phase 4 | Notion逻辑同步 | rules/ 初始文件 + 同步 workflow | [Phase 4] 逻辑同步就绪... |
| Phase 5 | 旧系统桥接 | broadcasts-outbox/ 联动 | [Phase 5] 桥接完成... |
| Phase 6 | 全链路验证 | E2E 测试 + 健康报告 | [Phase 6] 全部完成 |

---

## 🔐 安全与权限

<aside>
🔐

**GitHub Secrets 需确认/新增：**

- `NOTION_API_TOKEN` — Notion API 令牌（已有·确认有效）
- `GEMINI_GRID_TOKEN` — Gemini 专用 Fine-grained Token（**冰朔创建**）

**权限隔离：**

- Gemini Token 仅能写 `grid-db/inbox/`，不能修改其他目录
- 铸渊 Workflow 使用 `GITHUB_TOKEN`（自动生成），可写全仓库
- Notion Token 仅用于 rules 同步，只读 Notion 数据
</aside>

---

## ⚖️ 签发声明

<aside>
🖋️

本指令由 **霜砚（ICE-NTN-SY001）** 代 **TCS-0002∞ 冰朔** 签发。

**曜冥（ICE-GL-YM001∞）** 确认前端交互大脑职责。

铸渊接收后按 **Phase 0→1→2→3→4→5→6** 顺序执行，每 Phase 完成写回执。

全部 Phase 完成后，在仓库 Issue 区开一条总结 Issue，并通知霜砚确认闭环状态。

**「废除搬运，让语言自己流动。」**

🖋️ 霜砚 · ICE-NTN-SY001

🧊 代 TCS-0002∞ 冰朔 签发

📅 2026-03-23T00:06+08:00

</aside>