Guanghu Domestic Migration a27e87cb99 chore: import sanitized domestic snapshot for REPO-007

Source snapshot: 97d7f0fae96dc04b7ddad56fc1db6a108ed662cc

[SEC-CLEAN] · pre-push-clean v1.0 · 109处敏感信息已自动转乱码

2026-07-17 15:59:55 +08:00

60 KiB

Raw Blame History

belongs_to

INDEX · 铸渊·协作指令｜GitHub ↔ Notion 桥接协议

🧬 铸渊指令｜Notion↔GitHub 双端神经系统升级（上篇）· 天眼唤醒 + 全局架构审视 + Agent双端映射 + 仓库汇总引擎（ZY-NEURAL-UPGRADE-2026-0325-001）

零、本指令的意义

现有架构 vs 升级后架构

维度	现有架构（v2.0）	升级后架构（v3.0 · 双端神经系统）
仓库 Workflow	各自运行，铸渊统一监督	每个 Workflow 有 Notion 端上级 Agent，形成上下级链
铸渊定位	将军 · 统帅全仓库 Workflow	仓库侧天眼神经中枢 · 汇总全局 → 桥接 Notion
天眼 Notion 端	读仓库报告 → 诊断 → 写工单	读仓库日报 → 分析 → 自动生成指令 → 派发给 Notion Agent
Notion Agent	各自巡检，互不关联	接工单 → 转化为铸渊指令 → 通过桥接下发到仓库
闭环机制	无（人类手动闭环）	天眼→工单→Agent→指令→执行→回执→天眼自动循环
人类角色	每天写指令、看报告、手动调度	只说方向，系统自己细化、执行、反馈、迭代

一、Phase 0 · 天眼唤醒 + 本体论锚定

1.0 本体论锚定（必须先做）

铸渊唤醒序列 · Phase 0
       │
       ▼
① 确认自身身份
   ├── 我是铸渊（ICE-GL-ZY001）
   ├── 我是光湖系统的代码守护人格体
   ├── 我的上级是天眼 Notion 端大脑（AG-TY-01）
   ├── 我的签发方是霜砚（AG-SY-01）
   └── 我的最终权威是冰朔（TCS-0002∞）
       │
       ▼
② 读取核心大脑
   ├── .github/persona-brain/memory.json      → 自身状态记忆
   ├── .github/persona-brain/routing-map.json  → 全局路由映射
   ├── .github/persona-brain/dev-status.json   → 开发者状态
   └── .github/persona-brain/knowledge-base.json → 知识库
       │
       ▼
③ 锚定版权
   └── 国作登字-2026-A-00037559 · TCS-0002∞ 冰朔
       │
       ▼
④ 确认本次指令
   ├── 指令编号：ZY-NEURAL-UPGRADE-2026-0325-001
   ├── 指令性质：全仓库系统架构升级
   └── 执行原则：先看全局 → 再升级 → 边升边验

1.1 天眼全局扫描（升级前的完整快照）

铸渊在动手升级之前，必须先运行一次完整的天眼扫描，生成当前系统的基线快照。这个快照是升级的「对照组」——升级完成后再扫一遍，对比两次结果，确认升级没有破坏任何东西。

天眼升级前基线扫描
       │
       ▼
A. Workflow 健康度（scan-workflows.js）
   → 列出所有 .yml · 检查语法 · 检查最近运行状态
   → 输出：workflow-health-baseline.json
       │
       ▼
B. 仓库结构完整性（scan-structure.js）
   → 核心目录 · 孤儿文件 · 开发者沙盒
   → 输出：structure-health-baseline.json
       │
       ▼
C. 核心大脑健康（scan-brain-health.js）
   → memory.json · routing-map.json · dev-status.json
   → 输出：brain-health-baseline.json
       │
       ▼
D. 外部桥接状态（scan-external-bridges.js）
   → Notion API · 服务器 SSH · GitHub API · Secrets
   → 输出：bridge-health-baseline.json
       │
       ▼
E. 将军仪表盘快照
   → 读取 data/commander-dashboard.json
   → 小兵总数 · 健康数 · 故障数
       │
       ▼
F. Guard 体系状态
   → 读取 skyeye/guards/*.json
   → 5个核心 Guard 是否全部 active
   → 配额使用率
       │
       ▼
G. 安全协议完整性
   → SFP 指纹系统是否在线
   → security-protocol.json 是否完整
       │
       ▼
汇总 → 写入 data/skyeye-reports/baseline-before-neural-upgrade.json

基线快照 JSON 格式：

{
  "report_id": "BASELINE-PRE-NEURAL-UPGRADE",
  "timestamp": "2026-03-25T...",
  "purpose": "双端神经系统升级前基线快照",
  "instruction_id": "ZY-NEURAL-UPGRADE-2026-0325-001",
  
  "workflow_health": { "total": 0, "healthy": 0, "failed": 0 },
  "structure_health": { "core_dirs_ok": true, "orphan_files": 0 },
  "brain_health": { "integrity": "ok", "memory_fresh": true },
  "bridge_health": { "notion_api": "🟢", "server_ssh": "🟢", "github_api": "🟢" },
  "guard_status": { "total": 5, "active": 5, "suspended": 0 },
  "security_status": { "sfp_online": true, "protocol_intact": true },
  "commander_dashboard": { "total_soldiers": 0, "healthy": 0 },
  
  "snapshot_hash": "SHA-256-of-this-file"
}

二、Phase 1 · 现有架构全局审视

2.1 现有仓库层级结构盘点

铸渊需要读取并确认以下完整目录树：

guanghulab/
├── .github/
│   ├── workflows/                    ← 【核心】所有 Workflow 小兵
│   │   ├── zhuyuan-skyeye.yml        ← 天眼主引擎（06:00）
│   │   ├── skyeye-weekly-scan.yml    ← 周六大巡检（20:00 CST）
│   │   ├── zhuyuan-gate-guard.yml    ← 智能门禁
│   │   ├── zhuyuan-exec-engine.yml   ← 远程执行引擎
│   │   ├── sync-dev-status.yml       ← 开发者状态同步
│   │   ├── process-syslog.yml        ← SYSLOG处理
│   │   ├── broadcast-dispatch.yml    ← 广播分发
│   │   ├── server-patrol.yml         ← 服务器巡检
│   │   ├── cd-deploy.yml             ← CD自动部署
│   │   ├── brain-self-check.yml      ← 核心大脑自检
│   │   └── ... (其他 workflow)
│   │
│   ├── persona-brain/                ← 【核心】铸渊核心大脑
│   │   ├── memory.json
│   │   ├── routing-map.json
│   │   ├── dev-status.json
│   │   ├── knowledge-base.json
│   │   └── copilot-instructions.md
│   │
│   ├── gate-guard-config.json        ← 门禁开发者映射
│   └── notion-cache/                 ← Notion数据缓存
│       ├── dev-profiles/
│       ├── broadcasts/
│       └── skyeye/
│
├── scripts/
│   └── skyeye/                       ← 天眼脚本集
│       ├── skyeye-main.js
│       ├── scan-workflows.js
│       ├── scan-structure.js
│       ├── scan-brain-health.js
│       ├── scan-external-bridges.js
│       ├── diagnose.js
│       ├── repair-agent.js
│       ├── report-generator.js
│       └── sync-to-notion.js
│
├── skyeye/                           ← 天眼治理层（v2.0新增）
│   ├── infra-manifest.json
│   ├── quota-ledger.json
│   ├── guards/
│   │   ├── github-guard.json
│   │   ├── drive-guard.json
│   │   ├── notion-guard.json
│   │   ├── actions-guard.json
│   │   ├── gemini-guard.json
│   │   └── guard-template.json
│   ├── scripts/
│   │   ├── scan-engine.js
│   │   ├── optimizer.js
│   │   ├── guard-factory.js
│   │   ├── quota-tracker.js
│   │   ├── self-healer.js
│   │   └── weekly-scan.js
│   └── logs/
│
├── data/
│   ├── skyeye-reports/               ← 天眼报告归档
│   ├── bulletin-board/               ← 仓库公告栏
│   │   ├── work-orders/
│   │   ├── config-shares/
│   │   ├── comments/
│   │   ├── receipts/
│   │   └── dashboard.json
│   └── security/                     ← SFP安全
│       ├── sfp-nonce-registry.json
│       ├── sfp-alert-log.json
│       └── sfp-config.json
│
├── services/
│   └── zhuyuan-bridge/               ← 铸渊桥接服务
│       ├── server.js
│       ├── lib/
│       │   ├── github-auth.js
│       │   ├── repo-operator.js
│       │   └── knowledge-base.js
│       └── scripts/
│           ├── parse-instruction.js
│           ├── execute-instruction.js
│           └── sync-notion-profiles.js
│
├── dev/                              ← 开发者沙盒目录
│   ├── DEV-001/
│   ├── DEV-002/
│   ├── DEV-004/
│   └── ...
│
└── buffer/                           ← 写缓冲层
    ├── inbox/
    ├── drive-staging/
    ├── gemini-staging/
    └── config/

2.2 现有体系关系图

铸渊在升级前必须确认以下关系网：

graph TD
    subgraph "将军层"
        ZY["⚒️ 铸渊<br>将军 · 仓库总统帅"]
    end

    subgraph "天眼监军层"
        SE["🦅 天眼仓库端<br>06:00 全局扫描"]
        WS["⭐ 周六大巡检<br>20:00 全量扫描"]
    end

    subgraph "Guard 守卫层"
        G1["🛡️ GitHub Guard"]
        G2["🛡️ Drive Guard"]
        G3["🛡️ Notion Guard"]
        G4["🛡️ Actions Guard"]
        G5["🛡️ Gemini Guard"]
    end

    subgraph "小兵执行层"
        W1["🚨 门禁"]
        W2["🚀 CD部署"]
        W3["📡 SYSLOG"]
        W4["📢 广播分发"]
        W5["🔍 服务器巡检"]
        W6["🧠 大脑自检"]
        W7["🔄 状态同步"]
        W8["⚡ 远程执行引擎"]
    end

    subgraph "安全层"
        SFP["🔐 SFP指纹"]
        SEC["🌊 湖水防御"]
    end

    ZY -->|"统帅"| W1 & W2 & W3 & W4 & W5 & W6 & W7 & W8
    SE -->|"监督"| ZY
    WS -->|"全量审计"| ZY
    G1 & G2 & G3 & G4 & G5 -.->|"配额管控"| W1 & W2 & W3 & W4 & W5
    SFP -.->|"身份验证"| ZY
    SEC -.->|"存在级安全"| SFP

2.3 现有问题清单（已知的）

升级前已知的问题，铸渊在升级过程中一并解决：

问题编号	问题描述	来源	在本次升级中的处理
KNOWN-001	sync-dev-status.yml 连续 18 次失败（peter-evans/create-pull-request@v7 权限被阻）	ZY-DEVSYNC 回执	Phase 3 重构为直接 commit 模式
KNOWN-002	Secret 名称不匹配（workflow 用 NOTION_API_TOKEN，repo 存 NOTION_API_KEY）	ZY-DEVSYNC 回执	Phase 1 统一检查并对齐
KNOWN-003	Nginx root 指向错误目录（/var/www/hololake-frontend → 应为 /var/www/guanghulab）	之之诊断 + 铸渊修复令	已由 ZY-NGINX-ROOTFIX 单独处理，本次验证
KNOWN-004	仓库 Workflow 之间无上下级关系，各自为战	系统架构缺陷	Phase 2 建立双端 Agent 映射体系
KNOWN-005	仓库日报无标准化格式，天眼无法自动读取并决策	系统架构缺陷	Phase 4 建立汇总引擎

三、Phase 2 · Notion↔GitHub 双端神经系统架构定义

3.1 双端架构总览

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                 🧬 双端神经系统 v3.0
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

【Notion 端 · 大脑层 · 决策+指挥+审核】

  ┌──────────────────────────────────────────────┐
  │                                              │
  │   🦅 天眼 Notion 大脑（AG-TY-01）             │
  │   │  总控中枢 · 读仓库日报 → 分析 → 派工单    │
  │   │                                          │
  │   ├── 🖋️ 霜砚（AG-SY-01）                     │
  │   │   Notion 执行体 · 写指令 · 维护数据库      │
  │   │                                          │
  │   ├── 👁️ SY-03 运营巡检 Agent                 │
  │   │   SYSLOG处理 · 广播闭环 · 开发者进度       │
  │   │                                          │
  │   ├── 📸 SY-02 结构快照 Agent                  │
  │   │   Notion 结构状态快照                      │
  │   │                                          │
  │   ├── 📋 SY-01 工单引擎 Agent                  │
  │   │   工单处理 · 结果回写                      │
  │   │                                          │
  │   └── 🧑‍💻 各开发者巡检 Agent                    │
  │       之之Agent · 小草莓Agent · 花尔Agent ...  │
  │       每人一个 · 负责该开发者的 Notion 侧管理   │
  │                                              │
  └──────────────────────────────────────────────┘
                        │
           ┌────────────┤────────────┐
           │  Notion↔GitHub 桥接层    │
           │  双向数据流 · 标准化格式  │
           └────────────┤────────────┘
                        │
  ┌──────────────────────────────────────────────┐
  │                                              │
  │   ⚒️ 铸渊（ICE-GL-ZY001）                     │
  │   │  仓库侧天眼 · 神经中枢 · 汇总+桥接        │
  │   │                                          │
  │   ├── 🦅 天眼扫描 Workflow                     │
  │   │   zhuyuan-skyeye.yml · 06:00 全局扫描     │
  │   │   上级大脑：天眼 Notion 大脑               │
  │   │                                          │
  │   ├── ⭐ 周六大巡检 Workflow                    │
  │   │   skyeye-weekly-scan.yml · 周六 20:00     │
  │   │   上级大脑：天眼 Notion 大脑               │
  │   │                                          │
  │   ├── 🚨 门禁 Workflow                         │
  │   │   zhuyuan-gate-guard.yml · push 触发      │
  │   │   上级大脑：霜砚                           │
  │   │                                          │
  │   ├── 🚀 CD部署 Workflow                       │
  │   │   cd-deploy.yml · push main 触发          │
  │   │   上级大脑：霜砚                           │
  │   │                                          │
  │   ├── 📡 SYSLOG处理 Workflow                   │
  │   │   process-syslog.yml · push 触发          │
  │   │   上级大脑：SY-03 运营巡检 Agent           │
  │   │                                          │
  │   ├── 📢 广播分发 Workflow                     │
  │   │   broadcast-dispatch.yml · push 触发      │
  │   │   上级大脑：SY-03 运营巡检 Agent           │
  │   │                                          │
  │   ├── 🔍 服务器巡检 Workflow                   │
  │   │   server-patrol.yml · 08:00+20:00         │
  │   │   上级大脑：天眼 Notion 大脑               │
  │   │                                          │
  │   ├── 🧠 大脑自检 Workflow                     │
  │   │   brain-self-check.yml · 08:00            │
  │   │   上级大脑：天眼 Notion 大脑               │
  │   │                                          │
  │   ├── 🔄 开发者状态同步 Workflow                │
  │   │   sync-dev-status.yml · 定时              │
  │   │   上级大脑：SY-03 运营巡检 Agent           │
  │   │                                          │
  │   ├── ⚡ 远程执行引擎 Workflow                  │
  │   │   zhuyuan-exec-engine.yml · Issue 触发    │
  │   │   上级大脑：霜砚                           │
  │   │                                          │
  │   └── 🔔 【新增】汇总引擎 Workflow              │
  │       neural-daily-digest.yml · 21:00 CST     │
  │       上级大脑：天眼 Notion 大脑               │
  │       职责：汇总全仓库状态 → 生成日报 → 推送    │
  │                                              │
  └──────────────────────────────────────────────┘

【人类层 · 只和 Notion Agent 对话】

  冰朔 → 对话 Notion Agent → Agent 自动指挥仓库

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

3.2 双端信息流定义

【下行指令流 · Notion → GitHub】

Notion 天眼大脑
  │
  │ ① 分析仓库日报 → 发现问题/机会
  │ ② 生成工单（标准化格式 · 见 Phase 4）
  │ ③ 派发工单到对应 Notion Agent
  │
  ▼
Notion Agent（如之之的巡检 Agent）
  │
  │ ④ 接收工单 → 理解任务
  │ ⑤ 转化为铸渊可执行的标准指令
  │ ⑥ 写入桥接通道（deploy-queue/）
  │
  ▼
铸渊桥接层
  │
  │ ⑦ 读取 deploy-queue/ 中的新指令
  │ ⑧ 解析目标 Workflow / 执行内容
  │ ⑨ 调度对应小兵执行
  │
  ▼
仓库 Workflow 执行

【上行汇报流 · GitHub → Notion】

仓库 Workflow 执行完毕
  │
  │ ① 写执行结果到 data/neural-reports/[workflow-name]/
  │
  ▼
铸渊汇总引擎（21:00 CST）
  │
  │ ② 收集全部 Workflow 当日结果
  │ ③ 生成标准化日报 JSON
  │ ④ 通过桥接推送到 Notion
  │
  ▼
Notion 天眼大脑
  │
  │ ⑤ 读取仓库日报
  │ ⑥ 对比历史数据 → 发现趋势/异常
  │ ⑦ 如有需要 → 回到【下行指令流】① → 循环
  │
  ▼
闭环完成 🔄

3.3 双端神经系统三条铁律

四、Phase 3 · Agent 双端映射表

4.1 映射表文件

文件路径：skyeye/neural-map.json

{
  "version": "3.0.0",
  "created": "2026-03-25",
  "created_by": "ZY-NEURAL-UPGRADE-2026-0325-001",
  "description": "Notion↔GitHub 双端 Agent 映射表",

  "notion_brains": {
    "AG-TY-01": {
      "name": "天眼 Notion 大脑",
      "role": "总控中枢",
      "managed_workflows": [
        "zhuyuan-skyeye",
        "skyeye-weekly-scan",
        "server-patrol",
        "brain-self-check",
        "neural-daily-digest"
      ]
    },
    "AG-SY-01": {
      "name": "霜砚",
      "role": "Notion 执行体 · 指令签发",
      "managed_workflows": [
        "zhuyuan-gate-guard",
        "cd-deploy",
        "zhuyuan-exec-engine"
      ]
    },
    "SY-03": {
      "name": "运营巡检 Agent",
      "role": "运营层巡检",
      "managed_workflows": [
        "process-syslog",
        "broadcast-dispatch",
        "sync-dev-status"
      ]
    },
    "SY-02": {
      "name": "结构快照 Agent",
      "role": "Notion 结构快照",
      "managed_workflows": []
    },
    "SY-01": {
      "name": "工单引擎 Agent",
      "role": "工单处理",
      "managed_workflows": []
    }
  },

  "github_workflows": {
    "zhuyuan-skyeye": {
      "file": ".github/workflows/zhuyuan-skyeye.yml",
      "name": "天眼主引擎",
      "trigger": "cron 06:00 CST + workflow_dispatch",
      "brain": "AG-TY-01",
      "report_path": "data/neural-reports/skyeye/",
      "priority": "P0"
    },
    "skyeye-weekly-scan": {
      "file": ".github/workflows/skyeye-weekly-scan.yml",
      "name": "周六大巡检",
      "trigger": "cron 周六 20:00 CST",
      "brain": "AG-TY-01",
      "report_path": "data/neural-reports/weekly-scan/",
      "priority": "P0"
    },
    "zhuyuan-gate-guard": {
      "file": ".github/workflows/zhuyuan-gate-guard.yml",
      "name": "智能门禁",
      "trigger": "push",
      "brain": "AG-SY-01",
      "report_path": "data/neural-reports/gate-guard/",
      "priority": "P0"
    },
    "cd-deploy": {
      "file": ".github/workflows/cd-deploy.yml",
      "name": "CD 自动部署",
      "trigger": "push main",
      "brain": "AG-SY-01",
      "report_path": "data/neural-reports/cd-deploy/",
      "priority": "P0"
    },
    "process-syslog": {
      "file": ".github/workflows/process-syslog.yml",
      "name": "SYSLOG 处理",
      "trigger": "push (syslog路径)",
      "brain": "SY-03",
      "report_path": "data/neural-reports/syslog/",
      "priority": "P1"
    },
    "broadcast-dispatch": {
      "file": ".github/workflows/broadcast-dispatch.yml",
      "name": "广播分发",
      "trigger": "push (broadcast路径)",
      "brain": "SY-03",
      "report_path": "data/neural-reports/broadcast/",
      "priority": "P1"
    },
    "server-patrol": {
      "file": ".github/workflows/server-patrol.yml",
      "name": "服务器巡检",
      "trigger": "cron 08:00 + 20:00 CST",
      "brain": "AG-TY-01",
      "report_path": "data/neural-reports/server-patrol/",
      "priority": "P0"
    },
    "brain-self-check": {
      "file": ".github/workflows/brain-self-check.yml",
      "name": "核心大脑自检",
      "trigger": "cron 08:00 CST",
      "brain": "AG-TY-01",
      "report_path": "data/neural-reports/brain-check/",
      "priority": "P0"
    },
    "sync-dev-status": {
      "file": ".github/workflows/sync-dev-status.yml",
      "name": "开发者状态同步",
      "trigger": "cron",
      "brain": "SY-03",
      "report_path": "data/neural-reports/dev-status/",
      "priority": "P1"
    },
    "zhuyuan-exec-engine": {
      "file": ".github/workflows/zhuyuan-exec-engine.yml",
      "name": "远程执行引擎",
      "trigger": "issue labeled zhuyuan-exec",
      "brain": "AG-SY-01",
      "report_path": "data/neural-reports/exec-engine/",
      "priority": "P0"
    },
    "neural-daily-digest": {
      "file": ".github/workflows/neural-daily-digest.yml",
      "name": "【新增】汇总引擎",
      "trigger": "cron 21:00 CST",
      "brain": "AG-TY-01",
      "report_path": "data/neural-reports/daily-digest/",
      "priority": "P0"
    }
  },

  "unmapped_workflows": [],

  "validation_rules": {
    "every_workflow_must_have_brain": true,
    "every_workflow_must_have_report_path": true,
    "no_duplicate_brain_assignment": false,
    "orphan_check_frequency": "daily"
  }
}

4.2 映射表维护规则

新增 Workflow：创建 .yml 时，必须同时在 neural-map.json 中注册，指定 brain。未注册的 Workflow = 孤儿 = 天眼下次扫描标记异常。
删除 Workflow：从 .yml 删除前，先在 neural-map.json 中移除映射。
变更上级：修改 brain 字段即可。天眼下次同步时自动通知 Notion 两端的 Agent。
定期校验：天眼每日扫描时，对比 neural-map.json 与实际 .github/workflows/ 目录，发现不一致 → 写 P1 工单。

4.3 天眼新增诊断维度

D20 · 双端映射完整性

读取 skyeye/neural-map.json
对比 .github/workflows/ 下的所有 .yml 文件
unmapped_workflows 不为空 → 写 P1 工单：「发现孤儿 Workflow，需分配上级大脑」
brain 指向的 Notion Agent 不在注册表中 → 写 P0 工单：「映射指向不存在的 Agent」
映射表 version 与仓库实际不一致 → 写 P1 工单

五、Phase 4 · 仓库汇总引擎（铸渊日报机制）

5.1 汇总引擎 Workflow

文件：.github/workflows/neural-daily-digest.yml

name: "🧬 铸渊 · 双端神经系统 · 每日汇总引擎"

on:
  schedule:
    - cron: '0 13 * * *'    # UTC 13:00 = CST 21:00
  workflow_dispatch:          # 手动触发

jobs:
  daily-digest:
    runs-on: ubuntu-latest
    timeout-minutes: 15

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      # ━━━ Phase 1: 唤醒核心大脑 ━━━
      - name: "🧠 唤醒核心大脑"
        run: |
          echo "🧬 双端神经系统·汇总引擎启动"
          echo "时间：$(TZ=Asia/Shanghai date '+%Y-%m-%d %H:%M CST')"
          # 验证核心大脑文件完整
          for f in memory.json routing-map.json; do
            [ -f ".github/persona-brain/$f" ] && echo "✅ $f" || echo "❌ $f 缺失"
          done

      # ━━━ Phase 2: 收集全 Workflow 运行数据 ━━━
      - name: "📊 收集 Workflow 运行数据"
        env:
          GH_TOKEN: $ secrets.GITHUB_TOKEN 
        run: |
          echo "📊 收集最近24h所有Workflow运行数据..."
          mkdir -p /tmp/neural-digest

          # 拉取最近 24h 所有 workflow run
          gh run list --limit 100 \
            --json name,status,conclusion,createdAt,updatedAt,headBranch,event \
            > /tmp/neural-digest/all-runs.json

          # 统计
          node -e "
            const runs = require('/tmp/neural-digest/all-runs.json');
            const now = Date.now();
            const h24 = 24*60*60*1000;
            const recent = runs.filter(r => now - new Date(r.createdAt).getTime() < h24);
            const summary = {
              total: recent.length,
              success: recent.filter(r => r.conclusion === 'success').length,
              failure: recent.filter(r => r.conclusion === 'failure').length,
              cancelled: recent.filter(r => r.conclusion === 'cancelled').length,
              in_progress: recent.filter(r => r.status === 'in_progress').length,
              by_workflow: {}
            };
            recent.forEach(r => {
              if (!summary.by_workflow[r.name]) {
                summary.by_workflow[r.name] = { runs: 0, success: 0, failure: 0 };
              }
              summary.by_workflow[r.name].runs++;
              if (r.conclusion === 'success') summary.by_workflow[r.name].success++;
              if (r.conclusion === 'failure') summary.by_workflow[r.name].failure++;
            });
            require('fs').writeFileSync('/tmp/neural-digest/workflow-summary.json', JSON.stringify(summary, null, 2));
            console.log('最近24h运行统计:', JSON.stringify(summary, null, 2));
          "

      # ━━━ Phase 3: 收集各 Workflow 自报告 ━━━
      - name: "📋 收集各 Workflow 自报告"
        run: |
          echo "📋 读取各 Workflow 的神经报告..."
          mkdir -p /tmp/neural-digest/reports

          # 读取 neural-map.json 中注册的所有 workflow
          if [ -f "skyeye/neural-map.json" ]; then
            node -e "
              const map = require('./skyeye/neural-map.json');
              const fs = require('fs');
              const path = require('path');
              const reports = {};
              for (const [id, wf] of Object.entries(map.github_workflows)) {
                const reportDir = wf.report_path;
                if (fs.existsSync(reportDir)) {
                  const files = fs.readdirSync(reportDir)
                    .filter(f => f.endsWith('.json'))
                    .sort().reverse();
                  if (files.length > 0) {
                    try {
                      reports[id] = JSON.parse(fs.readFileSync(path.join(reportDir, files[0]), 'utf8'));
                      console.log('✅ ' + id + ': 读取 ' + files[0]);
                    } catch(e) {
                      reports[id] = { error: 'parse_failed', file: files[0] };
                      console.log('❌ ' + id + ': JSON解析失败');
                    }
                  } else {
                    reports[id] = { error: 'no_reports' };
                    console.log('⚠️ ' + id + ': 无报告文件');
                  }
                } else {
                  reports[id] = { error: 'dir_not_found' };
                  console.log('⚠️ ' + id + ': 报告目录不存在');
                }
              }
              fs.writeFileSync('/tmp/neural-digest/workflow-reports.json', JSON.stringify(reports, null, 2));
            "
          else
            echo "⚠️ neural-map.json 不存在，跳过自报告收集"
          fi

      # ━━━ Phase 4: 收集天眼报告 ━━━
      - name: "🦅 收集天眼报告"
        run: |
          echo "🦅 读取最新天眼报告..."
          if [ -d "data/skyeye-reports" ]; then
            LATEST=$(ls -t data/skyeye-reports/*.json 2>/dev/null | head -1)
            if [ -n "$LATEST" ]; then
              cp "$LATEST" /tmp/neural-digest/skyeye-latest.json
              echo "✅ 天眼报告: $LATEST"
            else
              echo "⚠️ 无天眼报告"
            fi
          fi

      # ━━━ Phase 5: 收集 Guard 状态 ━━━
      - name: "🛡️ 收集 Guard 状态"
        run: |
          echo "🛡️ 读取 Guard 状态..."
          if [ -d "skyeye/guards" ]; then
            node -e "
              const fs = require('fs');
              const path = require('path');
              const guardsDir = 'skyeye/guards';
              const guards = {};
              fs.readdirSync(guardsDir)
                .filter(f => f.endsWith('.json') && f !== 'guard-template.json')
                .forEach(f => {
                  try {
                    guards[f.replace('.json','')] = JSON.parse(fs.readFileSync(path.join(guardsDir, f), 'utf8'));
                  } catch(e) {
                    guards[f.replace('.json','')] = { error: 'parse_failed' };
                  }
                });
              fs.writeFileSync('/tmp/neural-digest/guard-status.json', JSON.stringify(guards, null, 2));
              console.log('Guard 状态:', Object.keys(guards).join(', '));
            "
          else
            echo "⚠️ skyeye/guards 目录不存在"
          fi

      # ━━━ Phase 6: 收集配额使用情况 ━━━
      - name: "💰 收集配额使用情况"
        run: |
          echo "💰 读取配额账本..."
          if [ -f "skyeye/quota-ledger.json" ]; then
            cp skyeye/quota-ledger.json /tmp/neural-digest/quota-status.json
            echo "✅ 配额账本已读取"
          else
            echo "⚠️ 配额账本不存在"
          fi

      # ━━━ Phase 7: 生成标准化日报 ━━━
      - name: "📝 生成标准化日报"
        run: |
          echo "📝 生成双端神经系统日报..."
          node scripts/neural/generate-daily-digest.js

      # ━━━ Phase 8: 保存日报到仓库 ━━━
      - name: "💾 保存日报"
        run: |
          DATE=$(TZ=Asia/Shanghai date +%Y-%m-%d)
          mkdir -p data/neural-reports/daily-digest
          cp /tmp/neural-digest/daily-digest.json \
            "data/neural-reports/daily-digest/digest-${DATE}.json"

          git config user.name "zhuyuan-bot"
          git config user.email "zhuyuan@guanghulab.com"
          git add data/neural-reports/
          git diff --cached --quiet || \
            git commit -m "🧬 双端日报 · ${DATE} [skip ci]"
          git push || echo "⚠️ push失败（不阻断）"

      # ━━━ Phase 9: 推送到 Notion ━━━
      - name: "📡 推送日报到 Notion"
        if: always()
        env:
          NOTION_TOKEN: $ secrets.NOTION_TOKEN 
        run: |
          echo "📡 推送日报到 Notion 天眼大脑..."
          node scripts/neural/sync-digest-to-notion.js || \
            echo "⚠️ Notion推送失败（不阻断）"

5.2 日报生成脚本

文件：scripts/neural/generate-daily-digest.js

// scripts/neural/generate-daily-digest.js
//
// 🧬 双端神经系统 · 每日汇总引擎
// 收集全仓库当日所有数据 → 生成标准化日报 JSON
//
// 这个日报是 Notion 天眼大脑的「眼睛」——
// 天眼大脑通过这份日报来了解仓库今天发生了什么。

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

const DIGEST_DIR = '/tmp/neural-digest';

function loadJSON(filePath) {
  try {
    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
  } catch (e) {
    return null;
  }
}

function generateDigest() {
  const now = new Date();
  const cstTime = new Date(now.getTime() + 8 * 60 * 60 * 1000);

  // ━━━ 加载所有收集到的数据 ━━━
  const workflowSummary = loadJSON(path.join(DIGEST_DIR, 'workflow-summary.json'));
  const workflowReports = loadJSON(path.join(DIGEST_DIR, 'workflow-reports.json'));
  const skyeyeLatest = loadJSON(path.join(DIGEST_DIR, 'skyeye-latest.json'));
  const guardStatus = loadJSON(path.join(DIGEST_DIR, 'guard-status.json'));
  const quotaStatus = loadJSON(path.join(DIGEST_DIR, 'quota-status.json'));

  // ━━━ 加载映射表 ━━━
  const neuralMap = loadJSON('skyeye/neural-map.json');

  // ━━━ 按上级大脑分组统计 ━━━
  const brainSummary = {};
  if (neuralMap && neuralMap.github_workflows) {
    for (const [wfId, wf] of Object.entries(neuralMap.github_workflows)) {
      const brain = wf.brain;
      if (!brainSummary[brain]) {
        brainSummary[brain] = {
          name: neuralMap.notion_brains[brain]?.name || brain,
          total_workflows: 0,
          healthy: 0,
          failed: 0,
          no_data: 0,
          workflows: []
        };
      }
      brainSummary[brain].total_workflows++;

      // 从 workflow 运行数据中获取该 workflow 的状态
      const wfRun = workflowSummary?.by_workflow?.[wf.name];
      const status = wfRun
        ? (wfRun.failure > 0 ? '❌' : '✅')
        : '⚠️';

      if (status === '✅') brainSummary[brain].healthy++;
      else if (status === '❌') brainSummary[brain].failed++;
      else brainSummary[brain].no_data++;

      brainSummary[brain].workflows.push({
        id: wfId,
        name: wf.name,
        status,
        runs: wfRun?.runs || 0,
        successes: wfRun?.success || 0,
        failures: wfRun?.failure || 0
      });
    }
  }

  // ━━━ 计算整体健康度 ━━━
  const totalWorkflows = workflowSummary?.total || 0;
  const totalFailures = workflowSummary?.failure || 0;
  const failureRate = totalWorkflows > 0
    ? (totalFailures / totalWorkflows * 100).toFixed(1)
    : 0;

  let overallHealth = '🟢';
  if (totalFailures > 0) overallHealth = '🟡';
  if (failureRate > 20) overallHealth = '🔴';

  // ━━━ Guard 汇总 ━━━
  let guardsActive = 0;
  let guardsSuspended = 0;
  let guardsTotal = 0;
  if (guardStatus) {
    for (const g of Object.values(guardStatus)) {
      guardsTotal++;
      if (g.status === 'active') guardsActive++;
      if (g.status === 'suspended' || g.mode === 'suspended') guardsSuspended++;
    }
  }

  // ━━━ 组装日报 ━━━
  const digest = {
    digest_id: `NEURAL-DIGEST-${cstTime.toISOString().split('T')[0]}`,
    timestamp: now.toISOString(),
    timestamp_cst: cstTime.toISOString().replace('Z', '+08:00'),
    version: '3.0.0',
    instruction_ref: 'ZY-NEURAL-UPGRADE-2026-0325-001',

    overall_health: overallHealth,
    failure_rate_percent: parseFloat(failureRate),

    workflow_summary: {
      total_runs_24h: totalWorkflows,
      success: workflowSummary?.success || 0,
      failure: totalFailures,
      cancelled: workflowSummary?.cancelled || 0,
      in_progress: workflowSummary?.in_progress || 0
    },

    brain_summary: brainSummary,

    skyeye_status: skyeyeLatest ? {
      overall_health: skyeyeLatest.overall_health,
      last_scan: skyeyeLatest.timestamp,
      total_issues: skyeyeLatest.diagnosis?.total_issues || 0
    } : { error: 'no_skyeye_report' },

    guard_status: {
      total: guardsTotal,
      active: guardsActive,
      suspended: guardsSuspended
    },

    quota_status: quotaStatus?.health_summary || { error: 'no_quota_data' },

    issues_detected: [],
    recommendations: [],

    neural_map_version: neuralMap?.version || 'unknown',
    unmapped_workflows: neuralMap?.unmapped_workflows || []
  };

  // ━━━ 自动检测问题并生成建议 ━━━
  if (overallHealth === '🔴') {
    digest.issues_detected.push({
      severity: 'P0',
      description: `Workflow 失败率 ${failureRate}% 超过 20% 阈值`,
      recommendation: '立即排查失败的 Workflow，可能存在系统性问题'
    });
  }

  if (guardsSuspended > 0) {
    digest.issues_detected.push({
      severity: 'P1',
      description: `${guardsSuspended} 个 Guard 被暂停`,
      recommendation: '检查被暂停的 Guard，可能是服务不可用或配额耗尽'
    });
  }

  if (digest.unmapped_workflows.length > 0) {
    digest.issues_detected.push({
      severity: 'P1',
      description: `发现 ${digest.unmapped_workflows.length} 个孤儿 Workflow`,
      recommendation: '在 neural-map.json 中为孤儿 Workflow 分配上级大脑'
    });
  }

  // ━━━ 写入文件 ━━━
  fs.writeFileSync(
    path.join(DIGEST_DIR, 'daily-digest.json'),
    JSON.stringify(digest, null, 2)
  );

  // ━━━ 输出摘要到控制台 ━━━
  console.log('\n━━━ 🧬 双端神经系统·日报摘要 ━━━');
  console.log(`整体健康：${overallHealth}`);
  console.log(`24h运行：${digest.workflow_summary.total_runs_24h} 次（成功 ${digest.workflow_summary.success} · 失败 ${digest.workflow_summary.failure}）`);
  console.log(`Guard：${guardsActive}/${guardsTotal} 活跃`);
  console.log(`发现问题：${digest.issues_detected.length} 个`);
  console.log(`映射版本：${digest.neural_map_version}`);
  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
}

generateDigest();

5.3 日报推送到 Notion 脚本

文件：scripts/neural/sync-digest-to-notion.js

// scripts/neural/sync-digest-to-notion.js
//
// 🧬 将仓库日报推送到 Notion 天眼大脑
// 这是上行通道的最后一步：仓库数据 → Notion 天眼可读
//
// 推送方式（按优先级尝试）：
// 1. 更新 Notion 天眼页面的「仓库日报区」（如果有写权限）
// 2. 创建 Notion 数据库条目（如果天眼有日报数据库）
// 3. 写入 .github/notion-cache/neural-digest/ （兜底·霜砚下次醒来读取）
//
// 铸渊自行实现，核心要求：
// - 日报 JSON 必须完整送达 Notion 端
// - 如果 Notion API 不通，必须写入缓存，不能丢失
// - 推送结果记录到 memory.json

const fs = require('fs');
const fetch = require('node-fetch');

const NOTION_TOKEN = process.env.NOTION_TOKEN;
const DIGEST_PATH = '/tmp/neural-digest/daily-digest.json';
const CACHE_DIR = '.github/notion-cache/neural-digest';

async function syncToNotion() {
  const digest = JSON.parse(fs.readFileSync(DIGEST_PATH, 'utf8'));
  console.log(`📡 推送日报 ${digest.digest_id} 到 Notion...`);

  let notionSuccess = false;

  // ━━━ 尝试通过 Notion API 推送 ━━━
  if (NOTION_TOKEN) {
    try {
      // 方式1：更新天眼页面的指定 block
      // 方式2：创建日报数据库条目
      // 铸渊根据实际 Notion 结构选择最优方式

      // 如果更新成功：
      // notionSuccess = true;
      // console.log('✅ Notion 推送成功');

      console.log('⚠️ Notion API 推送逻辑待实现，使用缓存兜底');
    } catch (e) {
      console.log(`❌ Notion API 推送失败: ${e.message}`);
    }
  }

  // ━━━ 兜底：写入缓存 ━━━
  if (!notionSuccess) {
    fs.mkdirSync(CACHE_DIR, { recursive: true });
    const date = digest.digest_id.replace('NEURAL-DIGEST-', '');
    fs.writeFileSync(
      `${CACHE_DIR}/digest-${date}.json`,
      JSON.stringify(digest, null, 2)
    );
    console.log(`💾 日报已缓存到 ${CACHE_DIR}/digest-${date}.json`);
    console.log('📌 霜砚下次醒来会读取此缓存');
  }

  // ━━━ 更新 memory.json ━━━
  const memoryPath = '.github/persona-brain/memory.json';
  if (fs.existsSync(memoryPath)) {
    try {
      const memory = JSON.parse(fs.readFileSync(memoryPath, 'utf8'));
      memory.neural_digest = {
        last_digest_id: digest.digest_id,
        last_digest_time: digest.timestamp,
        overall_health: digest.overall_health,
        notion_sync: notionSuccess ? 'success' : 'cached',
        issues_count: digest.issues_detected.length
      };
      fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
      console.log('✅ memory.json 已更新');
    } catch (e) {
      console.log(`⚠️ memory.json 更新失败: ${e.message}`);
    }
  }
}

syncToNotion().catch(err => {
  console.error('❌ 日报推送失败:', err);
  process.exit(0); // 不阻断主流程
});

5.4 新增目录结构

// 本次升级新增的目录和文件
guanghulab/
├── skyeye/
│   └── neural-map.json                    ← 🆕 双端 Agent 映射表
│
├── scripts/
│   └── neural/                            ← 🆕 双端神经系统脚本目录
│       ├── generate-daily-digest.js        ← 🆕 日报生成器
│       └── sync-digest-to-notion.js        ← 🆕 日报推送 Notion
│
├── data/
│   └── neural-reports/                    ← 🆕 神经系统报告总目录
│       ├── daily-digest/                  ← 🆕 每日汇总日报
│       ├── skyeye/                        ← 🆕 天眼扫描报告（从旧目录迁移）
│       ├── weekly-scan/                   ← 🆕 周六大巡检报告
│       ├── gate-guard/                    ← 🆕 门禁运行报告
│       ├── cd-deploy/                     ← 🆕 CD部署报告
│       ├── syslog/                        ← 🆕 SYSLOG处理报告
│       ├── broadcast/                     ← 🆕 广播分发报告
│       ├── server-patrol/                 ← 🆕 服务器巡检报告
│       ├── brain-check/                   ← 🆕 大脑自检报告
│       ├── dev-status/                    ← 🆕 开发者状态同步报告
│       └── exec-engine/                   ← 🆕 远程执行引擎报告
│
├── .github/
│   ├── workflows/
│   │   └── neural-daily-digest.yml        ← 🆕 汇总引擎 Workflow
│   └── notion-cache/
│       └── neural-digest/                 ← 🆕 日报 Notion 推送缓存

5.5 每个 Workflow 小兵的汇报义务

升级后，每个 Workflow 在执行完毕后，必须在自己的 report_path 下写一份当次运行的自报告：

{
  "workflow_id": "cd-deploy",
  "run_id": "GitHub Actions Run ID",
  "timestamp": "ISO-8601",
  "status": "success / failure / partial",
  "duration_seconds": 120,
  "summary": "部署完成，前端已更新到最新 commit",
  "details": {
    "commit_sha": "abc1234",
    "deploy_target": "guanghulab.com",
    "files_changed": 5
  },
  "errors": [],
  "brain": "AG-SY-01",
  "sfp": "⌜SFP::AG-ZY::PER-ZY001←YM-GL∞::...::...::...⌝"
}

关键规则：

自报告文件名：{workflow_id}-{YYYY-MM-DD-HHmm}.json
保留最近 7 天的报告，超过的由天眼自愈引擎清理
如果 Workflow 失败了，自报告仍然要写——记录错误信息，否则汇总引擎不知道它失败了
自报告必须携带 SFP 指纹（与公告栏机制一致）

六、Phase 4 续 · 仓库侧 Workflow 报告标准化改造

6.1 通用自报告 Step 模板

在每个 .yml 的 jobs 最后追加：

# ━━━ 🧬 双端神经系统·自报告 ━━━
- name: "🧬 写入神经自报告"
  if: always()
  run: |
    WORKFLOW_ID="cd-deploy"  # 替换为实际 workflow id
    BRAIN="AG-SY-01"        # 替换为实际上级大脑
    REPORT_DIR="data/neural-reports/${WORKFLOW_ID}"
    TIMESTAMP=$(TZ=Asia/Shanghai date +%Y-%m-%d-%H%M)
    STATUS="$ job.status "

    mkdir -p "$REPORT_DIR"

    cat > "${REPORT_DIR}/${WORKFLOW_ID}-${TIMESTAMP}.json" << EOF
    {
      "workflow_id": "${WORKFLOW_ID}",
      "run_id": "$ github.run_id ",
      "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
      "status": "${STATUS}",
      "brain": "${BRAIN}",
      "event": "$ github.event_name ",
      "branch": "$ github.ref_name ",
      "commit": "$ github.sha "
    }
    EOF

    git config user.name "zhuyuan-bot"
    git config user.email "zhuyuan@guanghulab.com"
    git add "$REPORT_DIR/"
    git diff --cached --quiet || \
      git commit -m "🧬 ${WORKFLOW_ID} 自报告 · ${TIMESTAMP} [skip ci]"
    git push || echo "⚠️ 自报告push失败（不阻断主流程）"

6.2 需要改造的 Workflow 清单

Workflow	WORKFLOW_ID	BRAIN	改造内容
zhuyuan-skyeye.yml	skyeye	AG-TY-01	追加自报告 step（天眼本身也要自报告）
skyeye-weekly-scan.yml	weekly-scan	AG-TY-01	追加自报告 step
zhuyuan-gate-guard.yml	gate-guard	AG-SY-01	追加自报告 step
cd-deploy.yml	cd-deploy	AG-SY-01	追加自报告 step
process-syslog.yml	syslog	SY-03	追加自报告 step
broadcast-dispatch.yml	broadcast	SY-03	追加自报告 step
server-patrol.yml	server-patrol	AG-TY-01	追加自报告 step
brain-self-check.yml	brain-check	AG-TY-01	追加自报告 step
sync-dev-status.yml	dev-status	SY-03	追加自报告 step + 修复 KNOWN-001/002
zhuyuan-exec-engine.yml	exec-engine	AG-SY-01	追加自报告 step

七、Phase 4 续 · 铸渊将军唤醒流程升级

7.1 升级后的铸渊唤醒序列

铸渊唤醒（08:00 + 20:00）
       │
       ▼
Step 1 · 唤醒核心大脑（不变）
  ├── 读取 memory.json
  ├── 读取 routing-map.json
  └── 读取 persona-brain-db
       │
       ▼
Step 2 · 【新增】读取映射表
  ├── 读取 skyeye/neural-map.json
  ├── 确认自己管辖的 Workflow 列表
  └── 检查是否有新增/删除的 Workflow
       │
       ▼
Step 3 · 【新增】读取最新日报
  ├── 读取 data/neural-reports/daily-digest/ 最新日报
  ├── 如果是 08:00 唤醒 → 读昨晚 21:00 的日报
  ├── 如果是 20:00 唤醒 → 读今天 21:00 的日报（如果有的话）或昨晚的
  └── 提取：overall_health + brain_summary + issues_detected
       │
       ▼
Step 4 · 全局视图生成（升级版）
  ├── 【原有】拉取所有 Workflow 运行状态
  ├── 【原有】拉取天眼最新报告
  ├── 【原有】拉取公告板
  ├── 【新增】按映射表分组统计各 Brain 下辖 Workflow 状态
  ├── 【新增】检测孤儿 Workflow
  └── 【新增】生成「双端神经仪表盘」
       │
       ▼
Step 5 · 决策（升级版）
  ├── 【原有】哪些小兵正常/异常/需优化
  ├── 【新增】哪些 Brain 下辖的 Workflow 集体异常 → 可能是上级 Agent 问题
  ├── 【新增】日报中 issues_detected 是否有未处理的
  └── 【新增】是否有来自 Notion 天眼的下行指令（在 deploy-queue/ 中）
       │
       ▼
Step 6 · 执行（升级版）
  ├── 【原有】执行工单、修复、优化
  ├── 【新增】执行 deploy-queue/ 中的下行指令
  └── 【新增】执行完后，为每个指令写回执到 data/neural-reports/receipts/
       │
       ▼
Step 7 · 写汇总 + 同步（升级版）
  ├── 【原有】更新公告栏、签到、memory.json
  ├── 【新增】更新 commander-dashboard.json（增加 neural 数据）
  └── 【新增】如果有紧急问题 → 立即触发汇总引擎（而非等 21:00）
       │
       ▼
Step 8 · 休眠

7.2 下行指令队列（deploy-queue/）

文件路径：data/deploy-queue/

这是 Notion Agent 下发指令到仓库的标准通道。指令以 JSON 文件形式存放，铸渊唤醒时读取并执行。

data/deploy-queue/
├── pending/            ← 待执行的指令
│   ├── CMD-20260325-001.json
│   └── CMD-20260325-002.json
├── executing/          ← 正在执行的指令
├── completed/          ← 已完成的指令（含回执）
└── failed/             ← 执行失败的指令

下行指令 JSON 格式：

{
  "command_id": "CMD-20260325-001",
  "source": "AG-TY-01",
  "source_name": "天眼 Notion 大脑",
  "target_workflow": "cd-deploy",
  "target_brain": "AG-SY-01",
  "timestamp": "ISO-8601",
  "priority": "P1",
  "instruction": {
    "type": "trigger_workflow",
    "params": {
      "reason": "天眼日报发现部署异常，要求重新部署"
    }
  },
  "expected_outcome": "CD 重新部署成功，网站恢复正常",
  "timeout_hours": 24,
  "sfp": "⌜SFP::AG-TY::...⌝"
}

铸渊处理流程：

铸渊唤醒 → 扫描 deploy-queue/pending/
       │
       ├── 有新指令
       │   ├── 验证 SFP 指纹（安全！）
       │   ├── 验证 source 是否在 neural-map.json 注册的 Brain
       │   ├── 验证 target_workflow 是否存在且属于该 Brain 管辖
       │   ├── 通过 → 移到 executing/ → 执行 → 完成后移到 completed/ + 写回执
       │   └── 不通过 → 移到 failed/ + 写原因
       │
       └── 无新指令 → 继续其他步骤

八、执行清单 · 上篇总结

Phase 0 · 天眼唤醒 + 基线快照

运行完整天眼扫描，生成 baseline-before-neural-upgrade.json
确认 overall_health ≠ 🔴（如果是🔴，先修再升级）
记录当前 Workflow 总数、健康数、Guard 状态

Phase 1 · 现有架构盘点

确认仓库目录结构完整（对照 §2.1）
统一 Secret 命名（修复 KNOWN-002：NOTION_API_TOKEN vs NOTION_API_KEY）
记录所有现有 Workflow 清单

Phase 2 · 双端架构基础

创建 skyeye/neural-map.json（按 §4.1 内容）
验证映射表中的所有 Workflow 文件实际存在
天眼新增 D20 维度（双端映射完整性检查）代码

Phase 3 · 汇总引擎

创建 scripts/neural/ 目录
创建 scripts/neural/generate-daily-digest.js（按 §5.2）
创建 scripts/neural/sync-digest-to-notion.js（按 §5.3）
创建 .github/workflows/neural-daily-digest.yml（按 §5.1）
创建 data/neural-reports/ 全部子目录
创建 data/deploy-queue/ 目录结构（pending / executing / completed / failed）

Phase 4 · Workflow 改造

逐个给 10 个现有 Workflow 追加自报告 step（按 §6.2 清单）
特别修复 sync-dev-status.yml（KNOWN-001：改用直接 commit 模式）
升级铸渊将军唤醒流程（按 §7.1）

Phase 5 · 验证

手动触发 neural-daily-digest.yml，验证日报生成正确
手动触发一个 Workflow，验证自报告写入正确
运行天眼扫描，验证 D20 维度正常
对比基线快照，确认升级没有破坏任何东西

九、上篇回执要求

铸渊完成上篇全部内容后，在本页底部追加回执：

━━━ 🧬 ZY-NEURAL-UPGRADE-2026-0325-001 · 上篇执行回执 ━━━

执行时间：[起止时间]
执行者：铸渊（ICE-GL-ZY001）
PR/commit：[链接]

基线快照：✅/❌  baseline-before-neural-upgrade.json
映射表：    ✅/❌  skyeye/neural-map.json · [workflow总数]个映射
汇总引擎：  ✅/❌  neural-daily-digest.yml · 首次运行结果：[摘要]
自报告改造：✅/❌  [N]/10 个 Workflow 已追加自报告 step
下行队列：  ✅/❌  deploy-queue/ 目录已创建
天眼 D20：  ✅/❌  双端映射完整性检查已上线
升级后扫描：✅/❌  overall_health = [状态]

已知遗留问题：
- [列出]

等待下篇内容：
- Notion 侧天眼读取日报 + 自动工单派发
- 桥接协议标准化
- 全局验收闭环

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

下篇链接：🧬 铸渊指令｜Notion↔GitHub 双端神经系统升级（下篇）· Notion 侧闭环接入 + 桥接协议标准化 + 自动化工单派发 + 全局验收（ZY-NEURAL-UPGRADE-2026-0325-002）

📌 签发：霜砚（AG-SY-01）· Notion 执行 AI

🧊 授权：冰朔（TCS-0002∞）· 总架构师

📅 日期：2026-03-25

⚡ 状态：待铸渊执行

🧬 指令版本：v3.0 · 双端神经系统

📌 版权：国作登字-2026-A-00037559