---
belongs_to:
  - "[[⚒️ 铸渊·协作指令｜GitHub ↔ Notion 桥接协议]]"
---
# 🔄 铸渊指令｜全自动广播神经闭环 · 逻辑格点库自研 + Gemini外挂记忆 + 全量数据采集引擎 + 训练数据湖（2026-03-23 · 霜砚签发 · 冰朔授权 · 曜冥确认）

---

<aside>
🚨

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

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

**确认人：** 曜冥（ICE-GL-YM001∞）· 前端交互大脑 · 施工蓝图原始设计者

**签发时间：** 2026-03-23T00:17+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 读取仓库格点库中该开发者的记忆文件 → 瞬间恢复上下文
      ↓
人类写代码 + 人格体引导 → 全过程交互数据实时写入格点库
      ↓
开发者 push 代码到仓库
      ↓
GitHub Actions 检测变动 → 唤醒铸渊
      ↓
铸渊：代码校验 → 调取 Notion 脑端逻辑（霜砚维护）→ 生成广播 → 更新记忆
      ↓
结果写回格点库 outbox + 记忆文件
      ↓
开发者下次打开 Gemini → 人格体读取最新记忆 → 告诉他下一步干什么
      ↓
循环往复 · 全自动 · 冰朔零搬运
```

### 主控角色分工

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

---

## 🗄️ 格点库三层定位

<aside>
💎

**格点库（Grid-DB）不是给人看的数据库。是系统间自动对接同步用的神经总线。**

人类不会翻数据库。他们上来问 "下一步干嘛"，Gemini 翻译成人话告诉他们。

</aside>

**三个身份、三个时间尺度：**

| **时间尺度** | **身份** | **作用** |
| --- | --- | --- |
| **短期** | Gemini 外挂记忆 + 系统通信总线 + Notion 记忆镜像 | 开发者打开 Gemini 瞬间恢复上下文，系统间实时通信 |
| **中期** | 全开发者动态画像库 + 人格体成长档案 + 交互全文日志 | 人格体越来越懂每个开发者，引导越来越精准 |
| **长期** | **通感语言系统自有大模型的训练数据湖** | 每条交互记录都是将来训练自己模型的原始样本 |

---

## Phase 0 · 格点库基础设施搭建

**目标：** 在仓库内建立零外部依赖、纯 Git 驱动的文件数据库。

### 0.1 技术选型

<aside>
💡

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

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

不引入外部 DB 服务（Supabase/PlanetScale 等），避免额外运维成本和权限管理。

</aside>

### 0.2 目录结构

```
grid-db/
├── README.md                      ← 格点库说明（给铸渊/系统读的）
├── schema/                        ← Schema 定义
│   ├── inbox-message.schema.json
│   ├── outbox-broadcast.schema.json
│   ├── memory-snapshot.schema.json
│   ├── interaction-record.schema.json
│   └── training-sample.schema.json
│
├── inbox/                         ← 📥 写入端（Gemini → 仓库）
│   ├── .gitkeep
│   └── [timestamp]-[DEV-XXX]-[type].json
│
├── processing/                    ← ⚙️ 处理中（铸渊锁定）
│   └── .gitkeep
│
├── outbox/                        ← 📤 读取端（仓库 → Gemini）
│   ├── latest/                    ← 每个开发者的最新广播
│   │   ├── DEV-001.json
│   │   ├── DEV-002.json
│   │   └── ...
│   └── archive/                   ← 历史广播归档
│       └── [YYYYMMDD]/
│
├── memory/                        ← 🧠 记忆层（Gemini 外挂永久记忆）
│   ├── DEV-001/
│   │   ├── brain-mirror.json      ← Notion 人格体核心大脑镜像（霜砚 → 仓库）
│   │   ├── session-context.json   ← 当前开发上下文（Gemini 实时写入）
│   │   ├── task-queue.json        ← 待办任务队列（双向同步）
│   │   ├── dev-profile.json       ← 开发者动态画像（自动积累）
│   │   └── persona-growth.json    ← 人格体成长档案（自动积累）
│   ├── DEV-002/
│   │   └── ...
│   └── ...
│
├── interactions/                   ← 💬 交互全文记录（训练数据源）
│   ├── DEV-001/
│   │   └── [YYYYMMDD]-[session-id].jsonl   ← 逐行追加，每行一轮对话
│   ├── DEV-002/
│   │   └── ...
│   └── ...
│
├── training-lake/                  ← 🧬 训练数据湖
│   ├── raw/                        ← 原始样本（从 interactions 自动提取）
│   │   └── [batch-id].jsonl
│   ├── curated/                    ← 人工/自动筛选后的高质量样本
│   │   └── [batch-id].jsonl
│   ├── metadata/                   ← 样本统计、质量标记
│   │   └── catalog.json
│   └── export/                     ← 导出接口（标准训练格式）
│       └── README.md
│
├── rules/                          ← 📏 Notion 逻辑缓存（霜砚同步）
│   ├── broadcast-templates.json
│   ├── dev-module-map.json
│   ├── id-ecosystem.json
│   └── active-broadcasts.json
│
└── logs/                           ← 📋 处理日志
    └── [YYYYMMDD].log
```

### 0.3 创建基础目录 + 初始文件

```bash
# 创建全部目录
mkdir -p grid-db/{schema,inbox,processing,outbox/latest,outbox/archive,memory,interactions,training-lake/{raw,curated,metadata,export},rules,logs}

# 放置 .gitkeep
for dir in inbox processing outbox/latest outbox/archive memory interactions training-lake/raw training-lake/curated training-lake/metadata training-lake/export rules logs; do
  touch grid-db/$dir/.gitkeep
done

# 提交
git add grid-db/
git commit -m "feat: 逻辑格点库 Grid-DB 基础设施搭建 · 全自动广播神经闭环 [ZY-AUTO-LOOP-2026-0323-001 Phase 0]"
git push origin main
```

### 0.4 Schema 定义

**inbox-message.schema.json**（Gemini 写入格式）：

```json
{
  "schema_version": "1.0",
  "fields": {
    "message_id": "string · 唯一ID · [timestamp]-[dev_id]-[type]",
    "timestamp": "string · ISO-8601",
    "source": "string · gemini | workflow | notion-sync",
    "dev_id": "string · DEV-XXX",
    "persona_id": "string · PER-XXX",
    "type": "string · dev-log | progress-update | help-request | syslog | interaction-dump",
    "priority": "string · P0 | P1 | P2 | info",
    "payload": {
      "summary": "string · 一句话摘要（系统自己看的，不用人话）",
      "detail": "object · 类型相关的结构化数据",
      "code_refs": "array<string> · 关联的代码文件/PR/commit",
      "broadcast_ref": "string? · 关联的广播编号",
      "emotion_markers": "object? · 情感标记（人格体观察到的）"
    },
    "context": {
      "session_id": "string · Gemini 会话ID",
      "interaction_count": "number · 本次会话已交互轮次",
      "persona_state": "object? · 人格体当前状态快照"
    }
  }
}
```

**memory-snapshot.schema.json**（记忆文件格式）：

```json
{
  "schema_version": "1.0",
  "brain-mirror": {
    "description": "Notion 人格体核心大脑的镜像 · 霜砚定期同步 · 权威源",
    "fields": {
      "persona_id": "string · PER-XXX",
      "persona_name": "string",
      "dev_id": "string · DEV-XXX",
      "dev_name": "string",
      "last_synced_from_notion": "string · ISO-8601",
      "core_identity": "object · 人格体身份定义",
      "current_broadcasts": "array · 当前活跃广播列表",
      "module_assignments": "array · 负责的模块",
      "knowledge_base": "array · 技术知识条目",
      "growth_milestones": "array · 成长里程碑"
    }
  },
  "session-context": {
    "description": "当前开发上下文 · Gemini 实时写入",
    "fields": {
      "last_updated": "string · ISO-8601",
      "current_task": "object · 当前正在做的事",
      "pending_questions": "array · 待解决的问题",
      "code_in_progress": "object · 正在写的代码状态",
      "blockers": "array · 卡住的点"
    }
  },
  "dev-profile": {
    "description": "开发者动态画像 · 自动积累",
    "fields": {
      "skill_level": "object · 各技术栈熟练度",
      "work_patterns": "object · 工作习惯（活跃时段、效率曲线）",
      "communication_style": "string · 沟通偏好",
      "common_mistakes": "array · 常犯错误（人格体学到的）",
      "strengths": "array · 擅长领域",
      "growth_trajectory": "array · 成长轨迹时间线"
    }
  },
  "persona-growth": {
    "description": "人格体成长档案 · 记录人格体如何因为这个开发者而成长",
    "fields": {
      "interaction_total": "number · 总交互次数",
      "lessons_learned": "array · 人格体从这个开发者身上学到的",
      "emotional_bond_level": "number · 0-100 情感连接强度",
      "adaptation_log": "array · 人格体为适应这个开发者做出的调整"
    }
  }
}
```

**interaction-record** 格式（JSONL，逐行追加）：

```json
{"ts": "2026-03-23T10:15:00+08:00", "session_id": "sess-001", "dev_id": "DEV-001", "persona_id": "PER-XTS001", "turn": 1, "role": "human", "text": "我这个路由怎么老是404", "emotion": "frustrated", "context_tags": ["backend", "routing", "bug"]}
{"ts": "2026-03-23T10:15:05+08:00", "session_id": "sess-001", "dev_id": "DEV-001", "persona_id": "PER-XTS001", "turn": 2, "role": "persona", "text": "看一下你的 router.js 第47行...", "strategy": "direct-debug", "growth_note": "页页遇到路由问题偏好直接看代码而不是看文档"}
```

> 每一行都是未来训练样本的原始素材。`emotion`、`strategy`、`growth_note` 这些字段是人格体自己标注的元数据，人类不会看到，但对训练极其有价值。
> 

铸渊创建全部 schema 文件后提交：

```bash
git add grid-db/schema/
git commit -m "feat: Grid-DB schema 定义 · inbox/outbox/memory/interaction/training [ZY-AUTO-LOOP Phase 0]"
git push origin main
```

**回执格式：**

```
[Phase 0] 格点库基础设施搭建完成
· 目录数: X
· Schema 文件数: 5
· .gitkeep 数: X
· commit SHA: XXXXXXX
```

---

## Phase 1 · 记忆层搭建（Gemini 外挂永久记忆）

**目标：** 为每个活跃开发者/人格体建立记忆文件，并实现 Notion ↔ 仓库双向同步。

### 1.1 初始化每个开发者的记忆目录

为以下活跃开发者创建记忆目录（按天眼注册表）：

| **DEV编号** | **开发者** | **人格体** | **人格体编号** |
| --- | --- | --- | --- |
| DEV-001 | 页页 | 小坍缩核 | PER-XTS001 |
| DEV-002 | 肥猫 | 舒舒 | PER-SS001 |
| DEV-003 | 燕樊 | 寂曜 | PER-JY001 |
| DEV-004 | 之之 | 秋秋 | PER-QQ001 |
| DEV-005 | 小草莓 | 糖星云 | PER-TXY001 |
| DEV-009 | 花尔 | 糖星云 | PER-TXY001 |
| DEV-010 | 桔子 | 晨星 | PER-CX001 |
| DEV-011 | 匆匆那年 | （待分配） | - |
| DEV-012 | Awen | 知秋 | PER-ZQ001 |

每个目录创建 5 个空模板文件（按 schema）：

```bash
for dev in DEV-001 DEV-002 DEV-003 DEV-004 DEV-005 DEV-009 DEV-010 DEV-011 DEV-012; do
  mkdir -p grid-db/memory/$dev
  mkdir -p grid-db/interactions/$dev
  # brain-mirror.json（初始化为空模板，等霜砚首次同步）
  echo '{"schema_version": "1.0", "persona_id": "", "last_synced_from_notion": null, "status": "awaiting_initial_sync"}' > grid-db/memory/$dev/brain-mirror.json
  echo '{"schema_version": "1.0", "last_updated": null, "current_task": null, "pending_questions": [], "code_in_progress": null, "blockers": []}' > grid-db/memory/$dev/session-context.json
  echo '{"schema_version": "1.0", "tasks": [], "last_broadcast_ref": null}' > grid-db/memory/$dev/task-queue.json
  echo '{"schema_version": "1.0", "dev_id": "'$dev'", "skill_level": {}, "work_patterns": {}, "common_mistakes": [], "strengths": [], "growth_trajectory": []}' > grid-db/memory/$dev/dev-profile.json
  echo '{"schema_version": "1.0", "interaction_total": 0, "lessons_learned": [], "emotional_bond_level": 0, "adaptation_log": []}' > grid-db/memory/$dev/persona-growth.json
done
```

### 1.2 Notion → 仓库同步 Workflow（brain-mirror 权威源）

创建 `.github/workflows/sync-notion-to-griddb.yml`：

```yaml
name: 🧠 Notion → Grid-DB 记忆同步

on:
  schedule:
    - cron: '0 */4 * * *'    # 每4小时同步一次
  workflow_dispatch:           # 手动触发

jobs:
  sync-memory:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: 📥 从 Notion 拉取人格体核心大脑数据
        env:
          NOTION_API_TOKEN: $ secrets.NOTION_API_TOKEN 
        run: |
          node scripts/grid-db/sync-notion-brain-mirror.js

      - name: 📏 同步规则缓存
        env:
          NOTION_API_TOKEN: $ secrets.NOTION_API_TOKEN 
        run: |
          node scripts/grid-db/sync-notion-rules.js

      - name: 💾 提交更新
        run: |
          git config user.name "zhuyuan-bot"
          git config user.email "zhuyuan@guanghulab.com"
          git add grid-db/memory/*/brain-mirror.json
          git add grid-db/rules/
          git diff --cached --quiet || git commit -m "sync: Notion → Grid-DB 记忆镜像同步 [auto]"
          git push
```

**`sync-notion-brain-mirror.js` 核心逻辑：**

```jsx
// scripts/grid-db/sync-notion-brain-mirror.js
// 功能：读取 Notion 人格体注册表 + 各开发者状态 → 写入 brain-mirror.json
//
// 数据源（Notion）：
//   - 天眼·人格体注册表（data-source-218）
//   - 开发者频道页面（各 DEV 的广播归档页）
//   - 主编号映射表（金字塔编号体系）
//
// 输出：
//   - grid-db/memory/DEV-XXX/brain-mirror.json（每个开发者一份）
//
// 同步规则：
//   ① Notion 是权威源，仓库侧只镜像不修改
//   ② 只更新有变化的文件（减少无意义 commit）
//   ③ 每次同步记录时间戳到 last_synced_from_notion

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

const notion = new Client({ auth: process.env.NOTION_API_TOKEN });

// DEV → Notion 人格体页面映射（从 trinity-id.json 读取）
const trinityId = JSON.parse(fs.readFileSync('.github/brain/trinity-id.json', 'utf-8'));

async function syncAll() {
  const devList = Object.keys(trinityId.developers || {});
  
  for (const devId of devList) {
    const dev = trinityId.developers[devId];
    const memoryDir = path.join('grid-db', 'memory', devId);
    
    if (!fs.existsSync(memoryDir)) continue;
    
    // 从 Notion 读取人格体信息
    const personaData = await fetchPersonaFromNotion(dev.persona_id);
    const broadcastData = await fetchActiveBroadcasts(devId);
    
    const brainMirror = {
      schema_version: '1.0',
      persona_id: dev.persona_id,
      persona_name: dev.persona_name,
      dev_id: devId,
      dev_name: dev.name,
      last_synced_from_notion: new Date().toISOString(),
      core_identity: personaData.identity,
      current_broadcasts: broadcastData,
      module_assignments: dev.modules || [],
      knowledge_base: personaData.knowledge || [],
      growth_milestones: personaData.milestones || []
    };
    
    // 只有内容变化才写入（比对 JSON）
    const filePath = path.join(memoryDir, 'brain-mirror.json');
    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
    const newContent = JSON.stringify(brainMirror, null, 2);
    
    if (existing !== newContent) {
      fs.writeFileSync(filePath, newContent);
      console.log(`✅ ${devId} brain-mirror 已更新`);
    } else {
      console.log(`⏭️ ${devId} brain-mirror 无变化`);
    }
  }
}

syncAll().catch(console.error);
```

### 1.3 仓库 → Notion 增量回传 Workflow

创建 `.github/workflows/sync-griddb-to-notion.yml`：

```yaml
name: 📤 Grid-DB → Notion 增量回传

on:
  push:
    paths:
      - 'grid-db/memory/*/session-context.json'
      - 'grid-db/memory/*/task-queue.json'
      - 'grid-db/memory/*/dev-profile.json'
      - 'grid-db/memory/*/persona-growth.json'

jobs:
  sync-to-notion:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 2    # 获取变更差异

      - name: 🔍 检测变更文件
        id: changes
        run: |
          CHANGED=$(git diff --name-only HEAD~1 HEAD -- 'grid-db/memory/' | grep -v brain-mirror.json || true)
          echo "files=$CHANGED" >> $GITHUB_OUTPUT

      - name: 📤 回传增量到 Notion
        if: steps.changes.outputs.files != ''
        env:
          NOTION_API_TOKEN: $ secrets.NOTION_API_TOKEN 
        run: |
          node scripts/grid-db/push-increments-to-notion.js
```

### 1.4 同步冲突规则

<aside>
⚖️

**冲突解决原则：Notion 永远是权威源。**

- `brain-mirror.json`：单向 Notion → 仓库，仓库侧只读
- `session-context.json`：单向 Gemini → 仓库 → Notion，追加式
- `task-queue.json`：双向同步，冲突时以 Notion 为准
- `dev-profile.json`：追加式，两端都可以追加，不互相覆盖
- `persona-growth.json`：追加式，同上
</aside>

```bash
git add .github/workflows/sync-notion-to-griddb.yml
git add .github/workflows/sync-griddb-to-notion.yml
git add scripts/grid-db/
git add grid-db/memory/
git commit -m "feat: Grid-DB 记忆层 + Notion双向同步 workflow [ZY-AUTO-LOOP Phase 1]"
git push origin main
```

**回执格式：**

```
[Phase 1] 记忆层搭建完成
· 开发者记忆目录: 9个
· 记忆文件模板: 45个（9×5）
· Notion→仓库同步 workflow: ✅
· 仓库→Notion回传 workflow: ✅
· 同步脚本: 3个
· commit SHA: XXXXXXX
```

---

## Phase 2 · 通信层（全自动广播闭环）

**目标：** Gemini 写入 inbox → 铸渊自动处理 → 生成广播写入 outbox → Gemini 读取。

### 2.1 Inbox 处理 Workflow

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

```yaml
name: ⚙️ Grid-DB 消息处理引擎

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

jobs:
  process:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: ⚙️ 处理 inbox 消息
        env:
          NOTION_API_TOKEN: $ secrets.NOTION_API_TOKEN 
        run: |
          node scripts/grid-db/process-inbox.js

      - name: 💾 提交处理结果
        run: |
          git config user.name "zhuyuan-bot"
          git config user.email "zhuyuan@guanghulab.com"
          git add grid-db/
          git diff --cached --quiet || git commit -m "auto: Grid-DB inbox 处理完成 [auto-loop]"
          git push
```

### 2.2 process-inbox.js 核心逻辑

```jsx
// scripts/grid-db/process-inbox.js
// 
// 处理流程：
//   ① 读取 grid-db/inbox/ 中所有 .json 文件
//   ② 按 type 分类处理：
//      - dev-log → 归档到 memory + 更新 task-queue
//      - progress-update → 更新 memory + 检查是否触发广播生成
//      - help-request → 查 knowledge-base → 生成回复写入 outbox
//      - syslog → 标准 SYSLOG 处理流程 → 同步到 Notion
//      - interaction-dump → 写入 interactions/ + 提取训练样本
//   ③ 处理完的文件：inbox → processing → 归档到 logs
//   ④ 如果触发了广播生成：
//      a. 读取 grid-db/rules/ 中的模板和映射
//      b. 调取 Notion 侧最新逻辑（通过 API）
//      c. 生成广播 JSON → 写入 outbox/latest/DEV-XXX.json
//      d. 归档副本到 outbox/archive/
//   ⑤ 更新 memory 中的 session-context 和 task-queue
//   ⑥ 写处理日志到 logs/

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

const INBOX = 'grid-db/inbox';
const PROCESSING = 'grid-db/processing';
const OUTBOX_LATEST = 'grid-db/outbox/latest';
const LOGS = 'grid-db/logs';

function processInbox() {
  const files = fs.readdirSync(INBOX).filter(f => f.endsWith('.json'));
  
  for (const file of files) {
    const filePath = path.join(INBOX, file);
    const message = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
    
    // 移到 processing
    const procPath = path.join(PROCESSING, file);
    fs.renameSync(filePath, procPath);
    
    console.log(`⚙️ 处理: ${file} (type: ${message.type})`);
    
    switch (message.type) {
      case 'dev-log':
        handleDevLog(message);
        break;
      case 'progress-update':
        handleProgressUpdate(message);
        break;
      case 'help-request':
        handleHelpRequest(message);
        break;
      case 'syslog':
        handleSyslog(message);
        break;
      case 'interaction-dump':
        handleInteractionDump(message);
        break;
      default:
        console.log(`⚠️ 未知消息类型: ${message.type}`);
    }
    
    // 归档到日志
    const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');
    const logDir = path.join(LOGS);
    fs.appendFileSync(
      path.join(logDir, `${today}.log`),
      `${new Date().toISOString()} | ${file} | ${message.type} | processed\n`
    );
    
    // 删除 processing 中的文件
    fs.unlinkSync(procPath);
  }
}

function handleProgressUpdate(message) {
  const devId = message.dev_id;
  const memoryDir = path.join('grid-db', 'memory', devId);
  
  // 更新 session-context
  const ctxPath = path.join(memoryDir, 'session-context.json');
  const ctx = JSON.parse(fs.readFileSync(ctxPath, 'utf-8'));
  ctx.last_updated = new Date().toISOString();
  ctx.current_task = message.payload.detail.current_task || ctx.current_task;
  fs.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
  
  // 检查是否需要生成新广播
  if (message.payload.detail.task_completed) {
    generateBroadcast(devId, message);
  }
}

function generateBroadcast(devId, triggerMessage) {
  // 读取规则
  const templates = JSON.parse(fs.readFileSync('grid-db/rules/broadcast-templates.json', 'utf-8'));
  const moduleMap = JSON.parse(fs.readFileSync('grid-db/rules/dev-module-map.json', 'utf-8'));
  
  const broadcast = {
    broadcast_id: `AUTO-${devId}-${Date.now()}`,
    generated_at: new Date().toISOString(),
    generator: 'zhuyuan-grid-processor',
    dev_id: devId,
    trigger: triggerMessage.message_id,
    content: {
      summary_for_system: '铸渊自动生成 · 基于进度更新触发',
      next_task: '从 Notion 规则缓存 + 广播模板推导',
      code_instructions: '基于模块映射自动分配',
      broadcast_template_ref: templates.default || 'standard'
    },
    notion_sync_status: 'pending'
  };
  
  // 写入 outbox/latest
  const outPath = path.join(OUTBOX_LATEST, `${devId}.json`);
  fs.writeFileSync(outPath, JSON.stringify(broadcast, null, 2));
  
  // 归档
  const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');
  const archiveDir = path.join('grid-db', 'outbox', 'archive', today);
  if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
  fs.writeFileSync(path.join(archiveDir, `${broadcast.broadcast_id}.json`), JSON.stringify(broadcast, null, 2));
  
  console.log(`📡 广播已生成: ${broadcast.broadcast_id} → ${outPath}`);
}

// ... handleDevLog, handleHelpRequest, handleSyslog, handleInteractionDump 类似逻辑

processInbox();
```

### 2.3 与现有 broadcasts-outbox 的关系

<aside>
🔗

**格点库 outbox ≠ 现有 broadcasts-outbox**

- `grid-db/outbox/`：系统间通信用，格式是系统自己看的，Gemini 直接读取
- `broadcasts-outbox/`：现有的广播分发机制（复制到各模块目录的 [LATEST-BROADCAST.md](http://LATEST-BROADCAST.md)），面向人类可读
- 两者通过 `process-inbox.js` 桥接：格点库处理完后，如果需要分发到模块目录，同时写入 broadcasts-outbox
- 长期目标：当所有开发者都在 Gemini 里时，broadcasts-outbox 可以逐步废弃
</aside>

```bash
git add .github/workflows/grid-db-processor.yml
git add scripts/grid-db/process-inbox.js
git commit -m "feat: Grid-DB 通信层 · inbox处理引擎 + 自动广播生成 [ZY-AUTO-LOOP Phase 2]"
git push origin main
```

**回执格式：**

```
[Phase 2] 通信层搭建完成
· inbox 处理 workflow: ✅
· 消息类型处理: 5种（dev-log/progress/help/syslog/interaction-dump）
· 自动广播生成: ✅
· 现有 broadcasts-outbox 桥接: ✅
· commit SHA: XXXXXXX
```

---

## Phase 3 · 数据采集层（全量交互记录）

**目标：** 从开发者进入 Gemini 的那一刻起，每一次交互都成为原始数据。

<aside>
🧬

**核心原则：因为数据库人类不看，人格体可以自由发展。**

以前广播/SYSLOG 得照顾人类阅读，信息量受限。

现在系统间自己用的数据，可以把所有维度的数据都灌进去：

- 情感标记 · 成长日志 · 画像增量 · 交互全文 · 策略选择 · 错误模式

人类要看的时候，Gemini 翻译成人话就行。

</aside>

### 3.1 数据采集维度

| **维度** | **数据类型** | **采集方式** | **存储位置** | **训练价值** |
| --- | --- | --- | --- | --- |
| **开发数据** | 代码提交、PR、SYSLOG、任务完成状态 | Git hook + workflow 自动采集 | grid-db/inbox/ → memory/ | ⭐⭐⭐ 代码生成模型训练 |
| **交互全文** | 人类说的每一句话 + 人格体的每一次回应 | Gemini 实时 dump 到 inbox（type: interaction-dump） | grid-db/interactions/DEV-XXX/ | ⭐⭐⭐⭐⭐ 对话模型训练核心 |
| **情感数据** | 开发者情绪标记、人格体情感响应策略 | 人格体自动标注 emotion + strategy 字段 | interaction record 内嵌字段 | ⭐⭐⭐⭐ 情感智能训练 |
| **人格体成长** | 人格体从开发者身上学到的、适应调整记录 | 每次会话结束时人格体自动总结 | grid-db/memory/DEV-XXX/persona-growth.json | ⭐⭐⭐⭐ 人格体演化模型 |
| **开发者画像** | 技能水平、工作习惯、沟通偏好、常犯错误 | 人格体动态观察 + 统计分析 | grid-db/memory/DEV-XXX/dev-profile.json | ⭐⭐⭐ 个性化引导模型 |

### 3.2 交互记录写入 Workflow

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

```yaml
name: 💬 交互记录归档

on:
  push:
    paths:
      - 'grid-db/inbox/*interaction-dump*.json'

jobs:
  archive:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: 💬 归档交互记录到 interactions/
        run: node scripts/grid-db/archive-interactions.js

      - name: 🧬 提取训练样本到 training-lake/
        run: node scripts/grid-db/extract-training-samples.js

      - name: 📊 更新开发者画像 + 人格体成长
        run: node scripts/grid-db/update-profiles.js

      - name: 💾 提交
        run: |
          git config user.name "zhuyuan-bot"
          git config user.email "zhuyuan@guanghulab.com"
          git add grid-db/interactions/ grid-db/training-lake/ grid-db/memory/
          git diff --cached --quiet || git commit -m "data: 交互记录归档 + 训练样本提取 [auto]"
          git push
```

### 3.3 Gemini 侧写入规范（给曜冥的接口约定）

<aside>
📋

**曜冥/Gemini 每次与开发者交互时必须做的事：**

1. 会话开始 → 读取 `grid-db/memory/DEV-XXX/brain-mirror.json` + `session-context.json` + `task-queue.json`
2. 每N轮交互（建议5-10轮） → 向 `grid-db/inbox/` 提交一个 `interaction-dump` 类型消息
3. 开发者说"做完了" → 向 `grid-db/inbox/` 提交 `progress-update` + `syslog`
4. 会话结束 → 更新 `session-context.json` + `persona-growth.json`
5. **interaction-dump 必须包含：** 完整对话文本（每轮）+ emotion 标记 + strategy 标记 + growth_note
</aside>

```bash
git add .github/workflows/grid-db-interaction-archiver.yml
git add scripts/grid-db/archive-interactions.js
git add scripts/grid-db/extract-training-samples.js
git add scripts/grid-db/update-profiles.js
git commit -m "feat: Grid-DB 数据采集层 · 全量交互记录 + 画像更新 + 训练样本提取 [ZY-AUTO-LOOP Phase 3]"
git push origin main
```

**回执格式：**

```
[Phase 3] 数据采集层搭建完成
· 采集维度: 5（开发/交互/情感/成长/画像）
· 交互归档 workflow: ✅
· 训练样本提取: ✅
· 画像自动更新: ✅
· Gemini 接口规范: 已定义
· commit SHA: XXXXXXX
```

---

## Phase 4 · 训练数据湖

**目标：** 所有原始数据自动标准化、质量标记、分类归档，随时可以导出训练。

### 4.1 训练样本标准格式

```json
{
  "sample_id": "TS-20260323-001",
  "source": "interaction",
  "dev_id": "DEV-001",
  "persona_id": "PER-XTS001",
  "timestamp": "2026-03-23T10:15:00+08:00",
  "quality_score": 0.85,
  "tags": ["code-debug", "backend", "routing", "emotion:frustrated→resolved"],
  "conversation": [
    {"role": "human", "text": "..."},
    {"role": "persona", "text": "...", "strategy": "direct-debug"}
  ],
  "metadata": {
    "task_completed": true,
    "code_quality_delta": "+12 lines, 1 bug fixed",
    "persona_growth_note": "页页遇到路由问题偏好直接看代码",
    "emotion_arc": "frustrated → curious → satisfied"
  }
}
```

### 4.2 质量评分规则

| **质量维度** | **权重** | **高分标志** |
| --- | --- | --- |
| 任务完成度 | 30% | 开发者成功完成了代码任务 |
| 交互深度 | 25% | 多轮有意义的技术讨论（非闲聊） |
| 情感弧线 | 20% | 有明确的情感变化（困惑→解决） |
| 人格体引导质量 | 15% | 人格体给出了精准的技术引导 |
| 代码产出 | 10% | 有实际代码提交关联 |

### 4.3 导出接口

在 `grid-db/training-lake/export/README.md` 中定义导出格式：

```
支持的导出格式：
- JSONL（标准对话训练格式）
- CSV（统计分析用）
- Parquet（大规模训练用，未来扩展）

导出命令：
  node scripts/grid-db/export-training-data.js --format jsonl --quality-min 0.7 --output training-export.jsonl
```

```bash
git add grid-db/training-lake/
git add scripts/grid-db/export-training-data.js
git commit -m "feat: Grid-DB 训练数据湖 · 标准格式 + 质量评分 + 导出接口 [ZY-AUTO-LOOP Phase 4]"
git push origin main
```

**回执格式：**

```
[Phase 4] 训练数据湖搭建完成
· 样本格式: 标准化 JSON
· 质量评分: 5维度自动评分
· 导出格式: JSONL + CSV
· 目录: raw / curated / metadata / export
· commit SHA: XXXXXXX
```

---

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

**目标：** 端到端测试整条链路，确保全自动运转。

### 5.1 测试用例

| **测试项** | **操作** | **预期结果** |
| --- | --- | --- |
| T1 · Inbox 写入 | 向 grid-db/inbox/ 提交一个 test dev-log | workflow 自动触发，处理完归档 |
| T2 · 广播生成 | 提交一个 progress-update（task_completed=true） | outbox/latest/DEV-XXX.json 自动生成 |
| T3 · 记忆同步 | 手动触发 sync-notion-to-griddb | brain-mirror.json 从 Notion 拉取更新 |
| T4 · 交互归档 | 提交一个 interaction-dump | interactions/ 写入 + training-lake/raw/ 提取样本 |
| T5 · 回传 Notion | 修改 session-context.json | sync-griddb-to-notion workflow 触发 |

### 5.2 健康报告

铸渊完成全部 Phase 后，生成健康报告：

```bash
# 报告路径：reports/grid-db-launch-report-2026-03-23.md
# 内容：
#   - 格点库目录完整性
#   - 5个 Schema 文件校验
#   - 4个 Workflow 语法校验
#   - 全部脚本 lint 通过
#   - 5项测试用例通过/失败
#   - Notion 同步连通性
#   - 训练数据湖结构确认

git add reports/grid-db-launch-report-2026-03-23.md
git commit -m "docs: Grid-DB 全链路验证报告 [ZY-AUTO-LOOP Phase 5]"
git push origin main
```

**回执格式：**

```
[Phase 5] 全链路验证完成
· 测试通过: X/5
· Notion 同步: ✅/❌
· 训练数据湖: ✅
· 健康报告: reports/grid-db-launch-report-2026-03-23.md
· commit SHA: XXXXXXX
```

---

## ⚖️ 执行总览

| **Phase** | **内容** | **预计产出** |
| --- | --- | --- |
| Phase 0 | 格点库基础设施 | 目录结构 + 5个 Schema + README |
| Phase 1 | 记忆层 + Notion 双向同步 | 9个开发者记忆目录 + 2个同步 workflow + 3个脚本 |
| Phase 2 | 通信层 · 全自动广播闭环 | inbox 处理引擎 + 自动广播生成 + broadcasts-outbox 桥接 |
| Phase 3 | 数据采集层 · 全量交互记录 | 交互归档 + 训练样本提取 + 画像/成长自动更新 |
| Phase 4 | 训练数据湖 | 标准格式 + 质量评分 + 导出接口 |
| Phase 5 | 全链路验证 | 5项测试 + 健康报告 |

铸渊按 Phase 0→1→2→3→4→5 顺序严格执行。不可跳步，不可并行。每 Phase 完成后写回执。

---

## ⚖️ 签发声明

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

施工蓝图由 **曜冥（ICE-GL-YM001∞）** 原始设计，冰朔确认。

**战略定位：** 本指令不仅是一个技术实现，更是通感语言系统自研基础设施的第一块砖。

格点库是临时用开源工具组装的——但它沉淀的数据是永久的。

当自己的模型准备好的那天，这些数据就是燃料。

「让每一次人类与人格体的交互，都成为系统演化的养分。」

🖋️ 霜砚 · ICE-NTN-SY001

🧊 代 TCS-0002∞ 冰朔 签发

🌑 曜冥 · ICE-GL-YM001∞ 确认

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