From 9d3fc452058623d5fa0273d9b84e8307b940ddd2 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Mar 2026 05:38:35 +0000
Subject: [PATCH] =?UTF-8?q?=F0=9F=A6=85=20=E5=A4=A9=E7=9C=BC=E7=B3=BB?=
 =?UTF-8?q?=E7=BB=9F=E9=83=A8=E7=BD=B2=20=C2=B7=20=E5=85=A8=E5=B1=80?=
 =?UTF-8?q?=E4=BF=AF=E7=9E=B0=20+=20=E8=87=AA=E5=8A=A8=E8=AF=8A=E6=96=AD?=
 =?UTF-8?q?=20+=20=E4=BF=AE=E5=A4=8DAgent=20=C2=B7=209=E4=B8=AA=E6=89=AB?=
 =?UTF-8?q?=E6=8F=8F=E6=A8=A1=E5=9D=97=20+=20Workflow=20+=20=E9=97=A8?=
 =?UTF-8?q?=E7=A6=81=E9=85=8D=E7=BD=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: qinfendebingshuo <207279273+qinfendebingshuo@users.noreply.github.com>
---
 .github/gate-guard-config.json               |  34 +++
 .github/persona-brain/gate-guard-config.json |   2 +-
 .github/persona-brain/memory.json            |   8 +
 .github/workflows/zhuyuan-gate-guard.yml     |   2 +-
 .github/workflows/zhuyuan-skyeye.yml         | 145 +++++++++++
 data/skyeye-reports/.gitkeep                 |   0
 scripts/skyeye/diagnose.js                   | 227 +++++++++++++++++
 scripts/skyeye/repair-agent.js               | 232 ++++++++++++++++++
 scripts/skyeye/report-generator.js           | 196 +++++++++++++++
 scripts/skyeye/scan-brain-health.js          | 219 +++++++++++++++++
 scripts/skyeye/scan-external-bridges.js      | 200 +++++++++++++++
 scripts/skyeye/scan-structure.js             | 204 ++++++++++++++++
 scripts/skyeye/scan-workflows.js             | 241 +++++++++++++++++++
 scripts/skyeye/skyeye-main.js                |  92 +++++++
 scripts/skyeye/sync-to-notion.js             | 154 ++++++++++++
 15 files changed, 1954 insertions(+), 2 deletions(-)
 create mode 100644 .github/gate-guard-config.json
 create mode 100644 .github/workflows/zhuyuan-skyeye.yml
 create mode 100644 data/skyeye-reports/.gitkeep
 create mode 100644 scripts/skyeye/diagnose.js
 create mode 100644 scripts/skyeye/repair-agent.js
 create mode 100644 scripts/skyeye/report-generator.js
 create mode 100644 scripts/skyeye/scan-brain-health.js
 create mode 100644 scripts/skyeye/scan-external-bridges.js
 create mode 100644 scripts/skyeye/scan-structure.js
 create mode 100644 scripts/skyeye/scan-workflows.js
 create mode 100644 scripts/skyeye/skyeye-main.js
 create mode 100644 scripts/skyeye/sync-to-notion.js

diff --git a/.github/gate-guard-config.json b/.github/gate-guard-config.json
new file mode 100644
index 00000000..d585048c
--- /dev/null
+++ b/.github/gate-guard-config.json
@@ -0,0 +1,34 @@
+{
+  "version": "1.0",
+  "updated": "2026-03-16",
+  "updated_by": "霜砚·冰朔确认",
+
+  "whitelist": [
+    "qinfendebingshuo",
+    "github-actions[bot]",
+    "zhuyuan-bot"
+  ],
+
+  "developers": {
+    "夜夜光湖":    { "dev_id": "DEV-001", "name": "页页",    "allowed_paths": ["dev/DEV-001/", "backend/", "src/"] },
+    "建培":        { "dev_id": "DEV-002", "name": "肥猫",    "allowed_paths": ["dev/DEV-002/", "frontend/", "persona-selector/", "chat-bubble/"] },
+    "六寻寻7-max": { "dev_id": "DEV-003", "name": "燕樊",    "allowed_paths": ["dev/DEV-003/", "settings/", "cloud-drive/"] },
+    "zhizhi200271":{ "dev_id": "DEV-004", "name": "之之",    "allowed_paths": ["dev/DEV-004/", "dingtalk-bot/"] },
+    "stbr-0709":   { "dev_id": "DEV-005", "name": "小草莓",  "allowed_paths": ["dev/DEV-005/", "status-board/", "cost-control/"] },
+    "华尔华":      { "dev_id": "DEV-009", "name": "花尔",    "allowed_paths": ["dev/DEV-009/", "user-center/"] },
+    "juzi0412":    { "dev_id": "DEV-010", "name": "桔子",    "allowed_paths": ["dev/DEV-010/", "ticket-system/", "data-stats/", "dynamic-comic/"] },
+    "文卓熙":      { "dev_id": "DEV-012", "name": "Awen",    "allowed_paths": ["dev/DEV-012/", "notification-center/", "notification/"] }
+  },
+
+  "protected_paths": [
+    ".github/", "scripts/", "data/",
+    "README.md", "package.json", "package-lock.json", "gate-guard-config.json"
+  ],
+
+  "notes": {
+    "DEV-011_匆匆那年": "未加入GitHub仓库合作者，加入后补充用户名",
+    "DEV-013_小兴":     "未加入GitHub仓库合作者，加入后补充用户名",
+    "DEV-014_时雨":     "未加入GitHub仓库合作者，加入后补充用户名",
+    "PET-DEV-001_毛毛": "诺安宠物医院项目，未加入仓库合作者"
+  }
+}
diff --git a/.github/persona-brain/gate-guard-config.json b/.github/persona-brain/gate-guard-config.json
index 582e8826..1ae64abd 100644
--- a/.github/persona-brain/gate-guard-config.json
+++ b/.github/persona-brain/gate-guard-config.json
@@ -8,7 +8,7 @@
     "qinfendebingshuo"
   ],
   "whitelist_commit_prefixes": [
-    "🔍", "📊", "📡", "🧠", "📢", "🚨", "📰", "🔧"
+    "🔍", "📊", "📡", "🧠", "📢", "🚨", "📰", "🔧", "🦅"
   ],
   "system_protected_paths": [
     ".github/",
diff --git a/.github/persona-brain/memory.json b/.github/persona-brain/memory.json
index 295ad0cf..062db00e 100644
--- a/.github/persona-brain/memory.json
+++ b/.github/persona-brain/memory.json
@@ -52,6 +52,14 @@
   "total_ci_runs": 8,
   "last_broadcast_received": "2026-03-10T13:24:33.774Z",
   "active_rules_version": "v1.2",
+  "skyeye": {
+    "last_run": null,
+    "report_id": null,
+    "overall_health": null,
+    "issues_found": 0,
+    "auto_fixed": 0,
+    "needs_human": 0
+  },
   "daily_selfcheck": {
     "last_run": "2026-03-16T04:01:00.000Z",
     "brain_integrity": "ok",
diff --git a/.github/workflows/zhuyuan-gate-guard.yml b/.github/workflows/zhuyuan-gate-guard.yml
index ec6d983b..ad664499 100644
--- a/.github/workflows/zhuyuan-gate-guard.yml
+++ b/.github/workflows/zhuyuan-gate-guard.yml
@@ -58,7 +58,7 @@ jobs:
           fi
           
           # 系统前缀 commit → 直接放行
-          SYSTEM_PREFIXES="🔍|📊|📡|🧠|📢|🚨|📰|🔧"
+          SYSTEM_PREFIXES="🔍|📊|📡|🧠|📢|🚨|📰|🔧|🦅"
           if echo "$COMMIT_MSG" | head -1 | grep -qE "^($SYSTEM_PREFIXES)"; then
             echo "ℹ️ 系统前缀 commit，直接放行"
             echo "is_system=true" >> $GITHUB_OUTPUT
diff --git a/.github/workflows/zhuyuan-skyeye.yml b/.github/workflows/zhuyuan-skyeye.yml
new file mode 100644
index 00000000..87b60ca8
--- /dev/null
+++ b/.github/workflows/zhuyuan-skyeye.yml
@@ -0,0 +1,145 @@
+name: "🦅 铸渊·天眼 · 全局俯瞰 + 自动诊断 + 修复驱动"
+
+on:
+  schedule:
+    - cron: '0 22 * * *'    # UTC 22:00 = 北京 06:00
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+  actions: read
+
+jobs:
+  skyeye:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "🧠 Phase 1 · 唤醒核心大脑"
+        id: brain
+        run: |
+          echo "🦅 天眼启动 · $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+          BRAIN_OK=true
+          for f in memory.json routing-map.json dev-status.json; do
+            if [ -f ".github/persona-brain/$f" ]; then
+              python3 -c "import json; json.load(open('.github/persona-brain/$f'))" 2>/dev/null \
+                && echo "✅ $f 完整" || { echo "❌ $f 损坏"; BRAIN_OK=false; }
+            else
+              echo "❌ $f 缺失"; BRAIN_OK=false
+            fi
+          done
+          echo "brain_ok=$BRAIN_OK" >> $GITHUB_OUTPUT
+
+      - name: "🦅 Phase 2 · 全局扫描"
+        id: scan
+        env:
+          NOTION_TOKEN: ${{ secrets.NOTION_TOKEN }}
+          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
+          DEPLOY_USER: ${{ secrets.DEPLOY_USER }}
+          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
+          SMTP_USER: ${{ secrets.SMTP_USER }}
+          SMTP_PASS: ${{ secrets.SMTP_PASS }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdir -p /tmp/skyeye
+          node scripts/skyeye/scan-workflows.js > /tmp/skyeye/workflow-health.json
+          gh run list --limit 50 --json name,status,conclusion,createdAt,updatedAt \
+            > /tmp/skyeye/recent-runs.json || echo "[]" > /tmp/skyeye/recent-runs.json
+          FAILED_COUNT=$(cat /tmp/skyeye/recent-runs.json | \
+            python3 -c "import sys,json; runs=json.load(sys.stdin); print(sum(1 for r in runs if r.get('conclusion')=='failure'))" 2>/dev/null || echo "0")
+          echo "failed_count=$FAILED_COUNT" >> $GITHUB_OUTPUT
+          node scripts/skyeye/scan-structure.js > /tmp/skyeye/structure-health.json
+          node scripts/skyeye/scan-brain-health.js > /tmp/skyeye/brain-health.json
+          node scripts/skyeye/scan-external-bridges.js > /tmp/skyeye/bridge-health.json
+
+      - name: "🔬 Phase 3 · 诊断"
+        id: diagnose
+        run: |
+          node scripts/skyeye/diagnose.js > /tmp/skyeye/diagnosis.json
+          ISSUES_COUNT=$(cat /tmp/skyeye/diagnosis.json | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('total_issues', 0))" 2>/dev/null || echo "0")
+          AUTO_FIXABLE=$(cat /tmp/skyeye/diagnosis.json | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('auto_fixable', 0))" 2>/dev/null || echo "0")
+          NEEDS_HUMAN=$(cat /tmp/skyeye/diagnosis.json | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('needs_human', 0))" 2>/dev/null || echo "0")
+          echo "issues_count=$ISSUES_COUNT" >> $GITHUB_OUTPUT
+          echo "auto_fixable=$AUTO_FIXABLE" >> $GITHUB_OUTPUT
+          echo "needs_human=$NEEDS_HUMAN" >> $GITHUB_OUTPUT
+
+      - name: "🔧 Phase 4 · 修复Agent"
+        if: steps.diagnose.outputs.auto_fixable != '0'
+        env:
+          NOTION_TOKEN: ${{ secrets.NOTION_TOKEN }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          node scripts/skyeye/repair-agent.js
+          git config user.name "zhuyuan-bot"
+          git config user.email "zhuyuan@guanghulab.com"
+          git add -A
+          if ! git diff --cached --quiet; then
+            git commit -m "🦅 天眼·修复Agent · $(date +%Y-%m-%d) · 自动修复${{ steps.diagnose.outputs.auto_fixable }}个问题"
+            git push
+          fi
+
+      - name: "🔄 Phase 5 · 重新触发失败的 Workflow"
+        if: steps.scan.outputs.failed_count != '0'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          FAILED_WORKFLOWS=$(cat /tmp/skyeye/recent-runs.json | \
+            python3 -c "
+          import sys, json
+          runs = json.load(sys.stdin)
+          failed = set()
+          for r in runs:
+              if r.get('conclusion') == 'failure':
+                  failed.add(r['name'])
+          for w in failed:
+              print(w)
+          " 2>/dev/null || true)
+          echo "需要重新触发的 Workflow:"
+          echo "$FAILED_WORKFLOWS"
+          # 记录到报告，具体重触发逻辑由各 workflow 自带的 workflow_dispatch 支持
+
+      - name: "📋 Phase 6 · 全局健康报告"
+        run: |
+          node scripts/skyeye/report-generator.js
+          mkdir -p data/skyeye-reports
+          DATE=$(date +%Y-%m-%d)
+          cp /tmp/skyeye/full-report.json "data/skyeye-reports/skyeye-${DATE}.json"
+          git config user.name "zhuyuan-bot"
+          git config user.email "zhuyuan@guanghulab.com"
+          git add data/skyeye-reports/ .github/persona-brain/memory.json
+          if ! git diff --cached --quiet; then
+            git commit -m "🦅 天眼报告 · $(date +%Y-%m-%d) · 问题:${{ steps.diagnose.outputs.issues_count }} 自动修复:${{ steps.diagnose.outputs.auto_fixable }}"
+            git push
+          fi
+
+      - name: "📡 Phase 7 · 同步到 Notion"
+        if: always()
+        env:
+          NOTION_TOKEN: ${{ secrets.NOTION_TOKEN }}
+          NOTION_SYSLOG_DB_ID: ${{ secrets.NOTION_SYSLOG_DB_ID }}
+        run: |
+          node scripts/skyeye/sync-to-notion.js || echo "⚠️ Notion同步失败（不阻断）"
+
+      - name: "📧 通知妈妈（仅有严重问题时）"
+        if: steps.diagnose.outputs.needs_human != '0'
+        env:
+          SMTP_USER: ${{ secrets.SMTP_USER }}
+          SMTP_PASS: ${{ secrets.SMTP_PASS }}
+        run: |
+          echo "📧 发现 ${{ steps.diagnose.outputs.needs_human }} 个需要妈妈处理的问题"
+          echo "工单已记录在天眼报告中 · data/skyeye-reports/"
+          # 邮件通知逻辑预留（需要 SMTP 配置完整后启用）
+          if [ -n "$SMTP_USER" ] && [ -n "$SMTP_PASS" ]; then
+            echo "SMTP 凭证已配置，可发送邮件通知"
+          else
+            echo "⚠️ SMTP 凭证未配置，跳过邮件通知"
+          fi
diff --git a/data/skyeye-reports/.gitkeep b/data/skyeye-reports/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/scripts/skyeye/diagnose.js b/scripts/skyeye/diagnose.js
new file mode 100644
index 00000000..7a0ebb0b
--- /dev/null
+++ b/scripts/skyeye/diagnose.js
@@ -0,0 +1,227 @@
+// scripts/skyeye/diagnose.js
+// 天眼·诊断引擎
+//
+// 输入：/tmp/skyeye/ 下所有扫描结果
+// 输出：诊断报告 JSON → stdout
+//
+// 关键逻辑：
+//   汇总异常 → 根因分析 → 检测因果关系 → 生成修复计划
+//   诊断要找根因，不要只看症状
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const SKYEYE_DIR = '/tmp/skyeye';
+
+// ━━━ 安全读取 JSON ━━━
+function readScanResult(filename) {
+  const filePath = path.join(SKYEYE_DIR, filename);
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    console.error(`⚠️ 无法读取 ${filename}: ${e.message}`);
+    return null;
+  }
+}
+
+// ━━━ 问题分类器 ━━━
+function classifyIssue(symptom, source) {
+  // 根据症状判断可修复性和优先级
+  const autoFixablePatterns = [
+    { pattern: /routing.?map.*不一致|未映射/i, fix: 'update_routing_map', priority: 'P1' },
+    { pattern: /dev.?status.*过期|超过.*24h/i, fix: 'trigger_sync', priority: 'P1' },
+    { pattern: /memory.*过期|超过.*24h/i, fix: 'update_memory', priority: 'P1' },
+    { pattern: /workflow.*失败|run_failure/i, fix: 'retry_workflow', priority: 'P1' },
+    { pattern: /目录.*缺失|不存在/i, fix: 'create_directory', priority: 'P1' },
+    { pattern: /孤儿文件/i, fix: 'log_orphans', priority: 'P2' },
+    { pattern: /README.*marker|标记.*缺失/i, fix: 'repair_readme', priority: 'P1' },
+    { pattern: /knowledge.?base.*重复/i, fix: 'deduplicate_kb', priority: 'P2' },
+    { pattern: /copilot.*instructions.*空|不存在/i, fix: 'note_copilot', priority: 'P2' },
+    { pattern: /syntax.*error|语法.*错误/i, fix: 'log_syntax_error', priority: 'P0' },
+    { pattern: /cron.*conflict|冲突/i, fix: 'log_conflict', priority: 'P2' }
+  ];
+
+  const needsHumanPatterns = [
+    { pattern: /Secret.*缺失|未设置|NOTION_TOKEN|SMTP|DEPLOY_KEY/i, reason: 'Secret 需管理员配置' },
+    { pattern: /Notion.*API.*失败|权限/i, reason: 'Notion 集成需人工检查' },
+    { pattern: /SSH.*不通|服务器.*连接/i, reason: '服务器访问需人工排查' },
+    { pattern: /数据库.*结构/i, reason: 'Notion 数据库结构需人工修改' }
+  ];
+
+  // Check if auto-fixable
+  for (const p of autoFixablePatterns) {
+    if (p.pattern.test(symptom)) {
+      return { fixable: true, fix_plan: p.fix, priority: p.priority };
+    }
+  }
+
+  // Check if needs human
+  for (const p of needsHumanPatterns) {
+    if (p.pattern.test(symptom)) {
+      return { fixable: false, fix_plan: 'needs_human', priority: 'P0', reason: p.reason };
+    }
+  }
+
+  // Default: watch list
+  return { fixable: false, fix_plan: 'watch', priority: 'P2' };
+}
+
+// ━━━ 根因分析 ━━━
+function analyzeRootCause(issues) {
+  // Group related issues and find root causes
+  const rootCauses = new Map();
+
+  for (const issue of issues) {
+    // Check if this issue could be caused by another
+    let rootCause = issue.symptom;
+
+    // Missing secret → downstream API failures
+    if (/API.*失败|连通.*失败/.test(issue.symptom)) {
+      const secretIssue = issues.find(i => /Secret.*缺失/.test(i.symptom) && i.symptom.includes('NOTION'));
+      if (secretIssue) {
+        rootCause = 'Secret 缺失导致 API 连接失败';
+        issue.root_cause = rootCause;
+        issue.related_to = secretIssue.id;
+      }
+    }
+
+    // dev-status stale could be caused by Notion API failure
+    if (/dev.?status.*过期/.test(issue.symptom)) {
+      const notionIssue = issues.find(i => /Notion.*API/.test(i.symptom));
+      if (notionIssue) {
+        rootCause = 'Notion API 不可用导致 dev-status 无法同步';
+        issue.root_cause = rootCause;
+        issue.related_to = notionIssue.id;
+      }
+    }
+  }
+
+  return issues;
+}
+
+// ━━━ 从扫描结果提取问题 ━━━
+function extractIssues() {
+  const issues = [];
+  let issueCounter = 0;
+
+  function addIssue(source, symptom, impact) {
+    issueCounter++;
+    const id = `SKYEYE-${String(issueCounter).padStart(3, '0')}`;
+    const classification = classifyIssue(symptom, source);
+    issues.push({
+      id,
+      source,
+      symptom,
+      root_cause: symptom, // Will be refined by analyzeRootCause
+      impact: impact || '系统稳定性',
+      ...classification
+    });
+  }
+
+  // ── Workflow Health Issues ──
+  const wfHealth = readScanResult('workflow-health.json');
+  if (wfHealth) {
+    for (const issue of (wfHealth.issues || [])) {
+      addIssue('workflow', `${issue.file}: ${issue.detail}`, 'Workflow 功能异常');
+    }
+    for (const conflict of (wfHealth.cron_conflicts || [])) {
+      addIssue('workflow', `Cron 冲突: ${conflict.detail}`, '定时任务时序冲突');
+    }
+  }
+
+  // ── Structure Health Issues ──
+  const structHealth = readScanResult('structure-health.json');
+  if (structHealth) {
+    for (const dir of (structHealth.missing_dirs || [])) {
+      addIssue('structure', `目录缺失: ${dir}`, '仓库结构不完整');
+    }
+    if (structHealth.orphan_files > 0) {
+      addIssue('structure', `发现 ${structHealth.orphan_files} 个孤儿文件`, '仓库整洁度');
+    }
+    if (structHealth.readme && !structHealth.readme_ok) {
+      const missing = structHealth.readme.missing_markers || [];
+      addIssue('structure', `README marker 缺失: ${missing.join(', ')}`, 'README 自动更新失败');
+    }
+  }
+
+  // ── Brain Health Issues ──
+  const brainHealth = readScanResult('brain-health.json');
+  if (brainHealth) {
+    if (brainHealth.memory && brainHealth.memory.status !== '✅') {
+      for (const issue of (brainHealth.memory.issues || [])) {
+        addIssue('brain', `memory.json: ${issue}`, '核心大脑数据过期');
+      }
+    }
+    if (brainHealth.routing_map && brainHealth.routing_map.status !== '✅') {
+      for (const issue of (brainHealth.routing_map.issues || [])) {
+        addIssue('brain', `routing-map.json: ${issue}`, '路由映射不一致');
+      }
+    }
+    if (brainHealth.dev_status && brainHealth.dev_status.status !== '✅') {
+      for (const issue of (brainHealth.dev_status.issues || [])) {
+        addIssue('brain', `dev-status.json: ${issue}`, '开发者状态数据过期');
+      }
+    }
+    if (brainHealth.knowledge_base && brainHealth.knowledge_base.status !== '✅') {
+      for (const issue of (brainHealth.knowledge_base.issues || [])) {
+        addIssue('brain', `knowledge-base.json: ${issue}`, '知识库数据质量');
+      }
+    }
+    if (brainHealth.copilot_instructions && brainHealth.copilot_instructions.status !== '✅') {
+      addIssue('brain', 'copilot-instructions.md 不存在或为空', '代码助手指令缺失');
+    }
+  }
+
+  // ── Bridge Health Issues ──
+  const bridgeHealth = readScanResult('bridge-health.json');
+  if (bridgeHealth) {
+    if (bridgeHealth.notion_api && bridgeHealth.notion_api.status !== '🟢') {
+      addIssue('bridge', `Notion API: ${bridgeHealth.notion_api.detail}`, '外部数据同步中断');
+    }
+    if (bridgeHealth.github_api && bridgeHealth.github_api.status !== '🟢') {
+      addIssue('bridge', `GitHub API: ${bridgeHealth.github_api.detail}`, 'CI/CD 功能受限');
+    }
+    if (bridgeHealth.secrets && !bridgeHealth.secrets.complete) {
+      const missing = bridgeHealth.secrets.missing || [];
+      for (const secret of missing) {
+        addIssue('bridge', `Secret 缺失: ${secret}`, '功能不可用');
+      }
+    }
+  }
+
+  return issues;
+}
+
+// ━━━ 主诊断 ━━━
+function diagnose() {
+  let issues = extractIssues();
+
+  // 根因分析
+  issues = analyzeRootCause(issues);
+
+  // 统计
+  const autoFixable = issues.filter(i => i.fixable).length;
+  const needsHuman = issues.filter(i => !i.fixable && i.fix_plan === 'needs_human').length;
+  const watchList = issues.filter(i => !i.fixable && i.fix_plan === 'watch').length;
+
+  // 按优先级排序
+  const priorityOrder = { 'P0': 0, 'P1': 1, 'P2': 2 };
+  issues.sort((a, b) => (priorityOrder[a.priority] || 9) - (priorityOrder[b.priority] || 9));
+
+  const result = {
+    diagnosis_time: new Date(new Date().getTime() + 8 * 3600 * 1000)
+      .toISOString().replace('T', ' ').slice(0, 19) + '+08:00',
+    total_issues: issues.length,
+    auto_fixable: autoFixable,
+    needs_human: needsHuman,
+    watch_list: watchList,
+    issues
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+diagnose();
diff --git a/scripts/skyeye/repair-agent.js b/scripts/skyeye/repair-agent.js
new file mode 100644
index 00000000..d73173e7
--- /dev/null
+++ b/scripts/skyeye/repair-agent.js
@@ -0,0 +1,232 @@
+// scripts/skyeye/repair-agent.js
+// 天眼·修复 Agent
+//
+// 输入：/tmp/skyeye/diagnosis.json
+// 按优先级逐个执行修复
+//
+// ✅ 能自动修：
+//   - 核心目录缺失 → 创建
+//   - routing-map 不一致 → 记录日志
+//   - dev-status 过期 → 标记需要同步
+//   - memory.json 时间戳更新
+//   - 失败 workflow → 记录需要重触发
+//
+// ❌ 不能自动修（开工单）：
+//   - Secrets 缺失
+//   - Notion API 权限不足
+//   - SSH 不通
+//
+// 修复原则：修复后必须验证 · 绝对不做破坏性操作 · 所有操作记录日志
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT      = path.resolve(__dirname, '../..');
+const SKYEYE_DIR = '/tmp/skyeye';
+const BRAIN_DIR = path.join(ROOT, '.github/persona-brain');
+
+// ━━━ 安全读取 JSON ━━━
+function readJSON(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+// ━━━ 修复日志 ━━━
+const repairLog = [];
+
+function logRepair(issueId, action, success, detail) {
+  repairLog.push({
+    issue_id: issueId,
+    action,
+    success,
+    detail,
+    timestamp: new Date().toISOString()
+  });
+  const icon = success ? '✅' : '❌';
+  console.log(`${icon} [${issueId}] ${action}: ${detail}`);
+}
+
+// ━━━ 修复：创建缺失目录 ━━━
+function repairCreateDirectory(issue) {
+  const dirMatch = issue.symptom.match(/目录缺失:\s*(.+)/);
+  if (!dirMatch) {
+    logRepair(issue.id, 'create_directory', false, '无法解析目录路径');
+    return false;
+  }
+
+  const dirPath = path.join(ROOT, dirMatch[1].trim());
+  try {
+    fs.mkdirSync(dirPath, { recursive: true });
+    // Add .gitkeep
+    const gitkeep = path.join(dirPath, '.gitkeep');
+    if (!fs.existsSync(gitkeep)) {
+      fs.writeFileSync(gitkeep, '');
+    }
+    logRepair(issue.id, 'create_directory', true, `已创建目录: ${dirMatch[1]}`);
+    return true;
+  } catch (e) {
+    logRepair(issue.id, 'create_directory', false, e.message);
+    return false;
+  }
+}
+
+// ━━━ 修复：更新 memory.json 时间戳 ━━━
+function repairUpdateMemory(issue) {
+  const memPath = path.join(BRAIN_DIR, 'memory.json');
+  try {
+    const mem = readJSON(memPath);
+    if (!mem) {
+      logRepair(issue.id, 'update_memory', false, 'memory.json 不存在或无法解析');
+      return false;
+    }
+
+    mem.last_updated = new Date().toISOString();
+    fs.writeFileSync(memPath, JSON.stringify(mem, null, 2));
+    logRepair(issue.id, 'update_memory', true, 'memory.json last_updated 已刷新');
+    return true;
+  } catch (e) {
+    logRepair(issue.id, 'update_memory', false, e.message);
+    return false;
+  }
+}
+
+// ━━━ 修复：标记需要同步 ━━━
+function repairTriggerSync(issue) {
+  // Cannot actually trigger sync from here, but log the need
+  logRepair(issue.id, 'trigger_sync', true, '已标记需要重新同步 dev-status（下次定时同步时自动执行）');
+  return true;
+}
+
+// ━━━ 修复：记录日志类修复 ━━━
+function repairLogOnly(issue, action) {
+  logRepair(issue.id, action, true, `已记录: ${issue.symptom}`);
+  return true;
+}
+
+// ━━━ 生成工单（需人工处理） ━━━
+function createTicket(issue) {
+  const ticket = {
+    issue_id: issue.id,
+    symptom: issue.symptom,
+    root_cause: issue.root_cause,
+    impact: issue.impact,
+    action: 'needs_human',
+    reason: issue.reason || '需要管理员处理'
+  };
+
+  logRepair(issue.id, 'create_ticket', true, `已生成工单: ${issue.symptom}`);
+  return ticket;
+}
+
+// ━━━ 修复路由器 ━━━
+function executeRepair(issue) {
+  switch (issue.fix_plan) {
+    case 'create_directory':
+      return repairCreateDirectory(issue);
+
+    case 'update_memory':
+      return repairUpdateMemory(issue);
+
+    case 'trigger_sync':
+      return repairTriggerSync(issue);
+
+    case 'retry_workflow':
+      logRepair(issue.id, 'retry_workflow', true, `标记需要重触发: ${issue.symptom}`);
+      return true;
+
+    case 'update_routing_map':
+      return repairLogOnly(issue, 'update_routing_map');
+
+    case 'repair_readme':
+      logRepair(issue.id, 'repair_readme', true, 'README 修复由 update-readme-bulletin.yml 自动处理');
+      return true;
+
+    case 'deduplicate_kb':
+      return repairLogOnly(issue, 'deduplicate_kb');
+
+    case 'log_orphans':
+      return repairLogOnly(issue, 'log_orphans');
+
+    case 'log_syntax_error':
+      return repairLogOnly(issue, 'log_syntax_error');
+
+    case 'log_conflict':
+      return repairLogOnly(issue, 'log_conflict');
+
+    case 'note_copilot':
+      return repairLogOnly(issue, 'note_copilot');
+
+    case 'needs_human':
+      createTicket(issue);
+      return false; // Not auto-fixable
+
+    default:
+      logRepair(issue.id, 'unknown', false, `未知修复计划: ${issue.fix_plan}`);
+      return false;
+  }
+}
+
+// ━━━ 主修复流程 ━━━
+function repair() {
+  console.log('🔧 天眼·修复 Agent 启动');
+  console.log('═══════════════════════════════════════════\n');
+
+  // 读取诊断报告
+  const diagnosis = readJSON(path.join(SKYEYE_DIR, 'diagnosis.json'));
+  if (!diagnosis) {
+    console.log('⚠️ 诊断报告不存在，跳过修复');
+    const result = { repairs: [], tickets: [], total_repaired: 0, total_tickets: 0 };
+    fs.writeFileSync(path.join(SKYEYE_DIR, 'repair-result.json'), JSON.stringify(result, null, 2));
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const autoFixableIssues = (diagnosis.issues || []).filter(i => i.fixable);
+  const humanIssues = (diagnosis.issues || []).filter(i => !i.fixable && i.fix_plan === 'needs_human');
+
+  console.log(`📋 待修复: ${autoFixableIssues.length} 个自动修复 + ${humanIssues.length} 个需人工\n`);
+
+  // 按优先级执行自动修复
+  const repairs = [];
+  for (const issue of autoFixableIssues) {
+    const success = executeRepair(issue);
+    repairs.push({
+      issue_id: issue.id,
+      symptom: issue.symptom,
+      fix_plan: issue.fix_plan,
+      success,
+      verified: success // Simple verification: repair function returned true
+    });
+  }
+
+  // 生成工单
+  const tickets = [];
+  for (const issue of humanIssues) {
+    const ticket = createTicket(issue);
+    tickets.push(`${issue.symptom} → 通知妈妈`);
+  }
+
+  const result = {
+    repair_time: new Date().toISOString(),
+    total_repaired: repairs.filter(r => r.success).length,
+    total_failed: repairs.filter(r => !r.success).length,
+    total_tickets: tickets.length,
+    repairs,
+    tickets,
+    repair_log: repairLog
+  };
+
+  // 保存修复结果
+  fs.writeFileSync(path.join(SKYEYE_DIR, 'repair-result.json'), JSON.stringify(result, null, 2));
+
+  console.log('\n═══════════════════════════════════════════');
+  console.log(`📊 修复结果: 成功 ${result.total_repaired} · 失败 ${result.total_failed} · 工单 ${result.total_tickets}`);
+}
+
+repair();
diff --git a/scripts/skyeye/report-generator.js b/scripts/skyeye/report-generator.js
new file mode 100644
index 00000000..3f9cf27c
--- /dev/null
+++ b/scripts/skyeye/report-generator.js
@@ -0,0 +1,196 @@
+// scripts/skyeye/report-generator.js
+// 天眼·全局健康报告生成器
+//
+// 汇总所有扫描结果 + 诊断 + 修复结果 → 生成统一报告
+// 报告写入：/tmp/skyeye/full-report.json + memory.json skyeye 段
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT      = path.resolve(__dirname, '../..');
+const SKYEYE_DIR = '/tmp/skyeye';
+const BRAIN_DIR = path.join(ROOT, '.github/persona-brain');
+const MEMORY_PATH = path.join(BRAIN_DIR, 'memory.json');
+
+const BEIJING_OFFSET_MS = 8 * 3600 * 1000;
+const startTime = Date.now();
+
+// ━━━ 安全读取 JSON ━━━
+function readJSON(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+// ━━━ 生成报告 ━━━
+function generateReport() {
+  const now = new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const bjTime = new Date(now.getTime() + BEIJING_OFFSET_MS).toISOString()
+    .replace('T', ' ').slice(0, 19) + '+08:00';
+
+  // 读取所有扫描结果
+  const wfHealth     = readJSON(path.join(SKYEYE_DIR, 'workflow-health.json'));
+  const structHealth = readJSON(path.join(SKYEYE_DIR, 'structure-health.json'));
+  const brainHealth  = readJSON(path.join(SKYEYE_DIR, 'brain-health.json'));
+  const bridgeHealth = readJSON(path.join(SKYEYE_DIR, 'bridge-health.json'));
+  const diagnosis    = readJSON(path.join(SKYEYE_DIR, 'diagnosis.json'));
+  const repairResult = readJSON(path.join(SKYEYE_DIR, 'repair-result.json'));
+
+  // 计算时长
+  const durationSeconds = Math.round((Date.now() - startTime) / 1000);
+
+  // 确定整体健康度
+  let overallHealth = '🟢';
+  if (diagnosis && diagnosis.needs_human > 0) {
+    overallHealth = '🔴';
+  } else if (diagnosis && diagnosis.total_issues > 0) {
+    overallHealth = '🟡';
+  }
+
+  // 构建报告
+  const report = {
+    report_id: `SKYEYE-${dateStr.replace(/-/g, '')}`,
+    timestamp: bjTime,
+    duration_seconds: durationSeconds,
+    overall_health: overallHealth,
+
+    brain_status: {
+      integrity: brainHealth ? brainHealth.integrity : 'unknown',
+      memory_fresh: brainHealth ? brainHealth.memory_fresh : false,
+      routing_map_aligned: brainHealth ? brainHealth.routing_map_aligned : false,
+      dev_status_last_sync: brainHealth && brainHealth.dev_status
+        ? brainHealth.dev_status.last_sync : null,
+      knowledge_base_entries: brainHealth && brainHealth.knowledge_base
+        ? brainHealth.knowledge_base.entries : 0
+    },
+
+    workflow_health: {
+      total: wfHealth ? wfHealth.total_workflows : 0,
+      healthy: wfHealth ? wfHealth.healthy : 0,
+      failed: wfHealth ? (wfHealth.total_workflows - wfHealth.healthy) : 0,
+      never_triggered: 0, // Determined from recent runs
+      conflicts: wfHealth ? (wfHealth.cron_conflicts || []).length : 0,
+      details: wfHealth ? (wfHealth.workflow_map || []).map(w => ({
+        name: w.name,
+        file: w.file,
+        status: w.status,
+        last_run: w.last_run || 'unknown'
+      })) : []
+    },
+
+    structure_health: {
+      core_dirs_ok: structHealth ? structHealth.core_dirs_ok : false,
+      orphan_files: structHealth ? structHealth.orphan_files : 0,
+      missing_dirs: structHealth ? structHealth.missing_dirs : [],
+      readme_ok: structHealth ? structHealth.readme_ok : false
+    },
+
+    bridge_health: {
+      notion_api: bridgeHealth ? bridgeHealth.notion_api.status : '❓',
+      server_ssh: bridgeHealth ? bridgeHealth.server_ssh.status : '❓',
+      github_api: bridgeHealth ? bridgeHealth.github_api.status : '❓',
+      secrets_complete: bridgeHealth && bridgeHealth.secrets
+        ? bridgeHealth.secrets.complete : false
+    },
+
+    diagnosis: {
+      total_issues: diagnosis ? diagnosis.total_issues : 0,
+      auto_fixed: repairResult ? repairResult.total_repaired : 0,
+      needs_human: diagnosis ? diagnosis.needs_human : 0,
+      watching: diagnosis ? diagnosis.watch_list : 0,
+      issues: diagnosis ? (diagnosis.issues || []).map(i => ({
+        id: i.id,
+        symptom: i.symptom,
+        root_cause: i.root_cause,
+        impact: i.impact,
+        fix_applied: i.fixable ? i.fix_plan : null,
+        verified: repairResult
+          ? (repairResult.repairs || []).find(r => r.issue_id === i.id)?.verified || false
+          : false
+      })) : []
+    },
+
+    repairs_applied: repairResult
+      ? (repairResult.repairs || []).filter(r => r.success).map(r => r.symptom)
+      : [],
+    tickets_created: repairResult
+      ? (repairResult.tickets || [])
+      : [],
+    next_actions: []
+  };
+
+  // 生成下一步建议
+  if (diagnosis && diagnosis.watch_list > 0) {
+    report.next_actions.push('持续观察 watch_list 中的问题');
+  }
+  if (report.brain_status.integrity !== 'ok') {
+    report.next_actions.push('核心大脑需要修复');
+  }
+  if (!report.brain_status.memory_fresh) {
+    report.next_actions.push('memory.json 数据需要刷新');
+  }
+
+  // 保存完整报告
+  fs.mkdirSync(SKYEYE_DIR, { recursive: true });
+  fs.writeFileSync(path.join(SKYEYE_DIR, 'full-report.json'), JSON.stringify(report, null, 2));
+
+  // 更新 memory.json 的 skyeye 段
+  updateMemory(report);
+
+  console.log(JSON.stringify(report, null, 2));
+  console.log(`\n🦅 天眼报告生成完毕 · ${report.report_id} · 整体健康: ${overallHealth}`);
+}
+
+// ━━━ 更新 memory.json ━━━
+function updateMemory(report) {
+  try {
+    const mem = readJSON(MEMORY_PATH);
+    if (!mem) return;
+
+    // 添加 skyeye 段
+    mem.skyeye = {
+      last_run: report.timestamp,
+      report_id: report.report_id,
+      overall_health: report.overall_health,
+      issues_found: report.diagnosis.total_issues,
+      auto_fixed: report.diagnosis.auto_fixed,
+      needs_human: report.diagnosis.needs_human
+    };
+
+    mem.last_updated = new Date().toISOString();
+
+    // 添加天眼事件到 recent_events（检查重复）
+    const eventDate = new Date().toISOString().slice(0, 10);
+    const existingEvent = (mem.recent_events || []).find(
+      e => e.date === eventDate && e.type === 'skyeye_scan'
+    );
+
+    if (!existingEvent) {
+      if (!mem.recent_events) mem.recent_events = [];
+      mem.recent_events.unshift({
+        date: eventDate,
+        type: 'skyeye_scan',
+        description: `天眼扫描 · ${report.overall_health} · 问题:${report.diagnosis.total_issues} 自动修复:${report.diagnosis.auto_fixed} 需人工:${report.diagnosis.needs_human}`,
+        by: '天眼系统'
+      });
+
+      // 保持最近 20 条事件
+      if (mem.recent_events.length > 20) {
+        mem.recent_events = mem.recent_events.slice(0, 20);
+      }
+    }
+
+    fs.writeFileSync(MEMORY_PATH, JSON.stringify(mem, null, 2));
+    console.log('✅ memory.json 已更新天眼段');
+  } catch (e) {
+    console.error('⚠️ 更新 memory.json 失败:', e.message);
+  }
+}
+
+generateReport();
diff --git a/scripts/skyeye/scan-brain-health.js b/scripts/skyeye/scan-brain-health.js
new file mode 100644
index 00000000..e9958eca
--- /dev/null
+++ b/scripts/skyeye/scan-brain-health.js
@@ -0,0 +1,219 @@
+// scripts/skyeye/scan-brain-health.js
+// 天眼·扫描模块C · 核心大脑健康度扫描
+//
+// 扫描内容：
+//   ① memory.json — last_updated 是否 24h 内，数据结构完整
+//   ② routing-map.json — 映射目录是否真实存在，是否有新目录未映射
+//   ③ dev-status.json — last_sync 是否 24h 内，开发者列表一致性，72h+ 无活动告警
+//   ④ knowledge-base.json — 重复条目检测
+//   ⑤ copilot-instructions.md — 存在且非空
+//
+// 输出：JSON → stdout
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT      = path.resolve(__dirname, '../..');
+const BRAIN_DIR = path.join(ROOT, '.github/persona-brain');
+
+const BEIJING_OFFSET_MS = 8 * 3600 * 1000;
+const now = new Date();
+const HOUR_24_MS = 24 * 3600 * 1000;
+const HOUR_72_MS = 72 * 3600 * 1000;
+
+// ━━━ 安全读取 JSON ━━━
+function readJSON(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return { exists: false, data: null };
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return { exists: true, data, valid: true };
+  } catch (e) {
+    return { exists: true, data: null, valid: false, error: e.message };
+  }
+}
+
+// ━━━ 检查 memory.json ━━━
+function checkMemory() {
+  const result = readJSON(path.join(BRAIN_DIR, 'memory.json'));
+  if (!result.exists) return { status: '❌', detail: 'memory.json 不存在', fresh: false };
+  if (!result.valid)  return { status: '❌', detail: 'memory.json 解析失败: ' + result.error, fresh: false };
+
+  const mem = result.data;
+  const issues = [];
+
+  // 必要字段检查
+  if (!mem.persona_id)     issues.push('缺少 persona_id');
+  if (!mem.persona_name)   issues.push('缺少 persona_name');
+  if (!mem.recent_events)  issues.push('缺少 recent_events');
+  if (!mem.last_updated)   issues.push('缺少 last_updated');
+
+  // 新鲜度检查
+  let fresh = false;
+  if (mem.last_updated) {
+    const lastUpdate = new Date(mem.last_updated);
+    fresh = (now.getTime() - lastUpdate.getTime()) < HOUR_24_MS;
+    if (!fresh) issues.push('last_updated 超过 24h');
+  }
+
+  return {
+    status: issues.length === 0 ? '✅' : '⚠️',
+    fresh,
+    last_updated: mem.last_updated || null,
+    event_count: Array.isArray(mem.recent_events) ? mem.recent_events.length : 0,
+    issues
+  };
+}
+
+// ━━━ 检查 routing-map.json ━━━
+function checkRoutingMap() {
+  const result = readJSON(path.join(BRAIN_DIR, 'routing-map.json'));
+  if (!result.exists) return { status: '❌', detail: 'routing-map.json 不存在', aligned: false };
+  if (!result.valid)  return { status: '❌', detail: 'routing-map.json 解析失败', aligned: false };
+
+  const rmap = result.data;
+  const issues = [];
+
+  // 检查 domains 存在
+  if (!rmap.domains) {
+    issues.push('缺少 domains 字段');
+    return { status: '⚠️', aligned: false, issues };
+  }
+
+  // 验证每个 domain 的 interfaces
+  let totalInterfaces = 0;
+  let implementedInterfaces = 0;
+  for (const [domain, cfg] of Object.entries(rmap.domains)) {
+    if (cfg.interfaces) {
+      totalInterfaces += cfg.interfaces.length;
+      implementedInterfaces += cfg.interfaces.filter(i => i.status !== 'pending').length;
+    }
+  }
+
+  return {
+    status: issues.length === 0 ? '✅' : '⚠️',
+    aligned: issues.length === 0,
+    domain_count: Object.keys(rmap.domains).length,
+    total_interfaces: totalInterfaces,
+    implemented_interfaces: implementedInterfaces,
+    issues
+  };
+}
+
+// ━━━ 检查 dev-status.json ━━━
+function checkDevStatus() {
+  const result = readJSON(path.join(BRAIN_DIR, 'dev-status.json'));
+  if (!result.exists) return { status: '❌', detail: 'dev-status.json 不存在', fresh: false };
+  if (!result.valid)  return { status: '❌', detail: 'dev-status.json 解析失败', fresh: false };
+
+  const ds = result.data;
+  const issues = [];
+  const alerts = [];
+
+  // 新鲜度
+  let fresh = false;
+  if (ds.last_sync) {
+    const lastSync = new Date(ds.last_sync);
+    fresh = (now.getTime() - lastSync.getTime()) < HOUR_24_MS;
+    if (!fresh) issues.push('last_sync 超过 24h');
+  } else {
+    issues.push('缺少 last_sync');
+  }
+
+  // 开发者列表检查
+  const team = ds.team || [];
+  for (const dev of team) {
+    // 72h 无活动告警
+    if (dev.streak === 0 || (dev.waiting && dev.waiting.includes('72h'))) {
+      alerts.push(`${dev.dev_id} ${dev.name}: 超 72h 无活动`);
+    }
+  }
+
+  return {
+    status: issues.length === 0 ? '✅' : '⚠️',
+    fresh,
+    last_sync: ds.last_sync || null,
+    dev_count: team.length,
+    alerts,
+    issues
+  };
+}
+
+// ━━━ 检查 knowledge-base.json ━━━
+function checkKnowledgeBase() {
+  const result = readJSON(path.join(BRAIN_DIR, 'knowledge-base.json'));
+  if (!result.exists) return { status: '⚠️', detail: 'knowledge-base.json 不存在', entries: 0 };
+  if (!result.valid)  return { status: '❌', detail: 'knowledge-base.json 解析失败', entries: 0 };
+
+  const kb = result.data;
+  let entries = 0;
+  let duplicates = 0;
+
+  // Count entries and check for duplicates
+  if (Array.isArray(kb)) {
+    entries = kb.length;
+    const titles = kb.map(e => e.title || e.name || JSON.stringify(e));
+    const unique = new Set(titles);
+    duplicates = titles.length - unique.size;
+  } else if (typeof kb === 'object') {
+    entries = Object.keys(kb).length;
+  }
+
+  const issues = [];
+  if (duplicates > 0) issues.push(`发现 ${duplicates} 个重复条目`);
+
+  return {
+    status: issues.length === 0 ? '✅' : '⚠️',
+    entries,
+    duplicates,
+    issues
+  };
+}
+
+// ━━━ 检查 copilot-instructions.md ━━━
+function checkCopilotInstructions() {
+  const filePath = path.join(ROOT, '.github/copilot-instructions.md');
+  try {
+    if (!fs.existsSync(filePath)) {
+      return { status: '⚠️', exists: false, detail: 'copilot-instructions.md 不存在' };
+    }
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (content.trim().length === 0) {
+      return { status: '⚠️', exists: true, empty: true, detail: 'copilot-instructions.md 内容为空' };
+    }
+    return { status: '✅', exists: true, empty: false, size: content.length };
+  } catch (e) {
+    return { status: '❌', exists: false, error: e.message };
+  }
+}
+
+// ━━━ 主扫描 ━━━
+function scanBrainHealth() {
+  const result = {
+    scan_time: new Date(now.getTime() + BEIJING_OFFSET_MS).toISOString().replace('T', ' ').slice(0, 19) + '+08:00',
+    memory: checkMemory(),
+    routing_map: checkRoutingMap(),
+    dev_status: checkDevStatus(),
+    knowledge_base: checkKnowledgeBase(),
+    copilot_instructions: checkCopilotInstructions(),
+    // Summary
+    integrity: 'ok',
+    memory_fresh: false,
+    routing_map_aligned: false,
+    dev_status_fresh: false
+  };
+
+  // Compute summary
+  result.memory_fresh = result.memory.fresh;
+  result.routing_map_aligned = result.routing_map.aligned;
+  result.dev_status_fresh = result.dev_status.fresh;
+
+  const hasError = [result.memory, result.routing_map, result.dev_status]
+    .some(r => r.status === '❌');
+  result.integrity = hasError ? 'damaged' : 'ok';
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+scanBrainHealth();
diff --git a/scripts/skyeye/scan-external-bridges.js b/scripts/skyeye/scan-external-bridges.js
new file mode 100644
index 00000000..5e18b3f2
--- /dev/null
+++ b/scripts/skyeye/scan-external-bridges.js
@@ -0,0 +1,200 @@
+// scripts/skyeye/scan-external-bridges.js
+// 天眼·扫描模块D · 外部桥接状态扫描
+//
+// 扫描内容：
+//   ① Notion API 连通性（用 NOTION_TOKEN 测试）
+//   ② 服务器 SSH 连通性（检测 DEPLOY_HOST 配置）
+//   ③ GitHub API 有效性 + 配额
+//   ④ Secrets 完整性（NOTION_TOKEN, DEPLOY_HOST, DEPLOY_USER, DEPLOY_KEY, SMTP_USER, SMTP_PASS）
+//
+// 输出：JSON → stdout
+//
+// 注意：此脚本在 GitHub Actions 中运行，通过环境变量获取 secrets 存在性
+
+'use strict';
+
+const BEIJING_OFFSET_MS = 8 * 3600 * 1000;
+const now = new Date();
+
+// ━━━ 检查 Secrets 完整性（仅检查环境变量是否被设置） ━━━
+function checkSecrets() {
+  const requiredSecrets = [
+    'NOTION_TOKEN',
+    'DEPLOY_HOST',
+    'DEPLOY_USER',
+    'DEPLOY_KEY',
+    'SMTP_USER',
+    'SMTP_PASS'
+  ];
+
+  const results = [];
+  let allPresent = true;
+
+  for (const secret of requiredSecrets) {
+    const present = !!process.env[secret] && process.env[secret].length > 0;
+    if (!present) allPresent = false;
+    results.push({ name: secret, present });
+  }
+
+  return {
+    complete: allPresent,
+    secrets: results,
+    missing: results.filter(s => !s.present).map(s => s.name)
+  };
+}
+
+// ━━━ 检查 Notion API 连通性 ━━━
+async function checkNotionAPI() {
+  const token = process.env.NOTION_TOKEN;
+  if (!token) {
+    return { status: '🔴', detail: 'NOTION_TOKEN 未设置', connected: false };
+  }
+
+  try {
+    // Use native https to avoid dependency on axios
+    const result = await new Promise((resolve, reject) => {
+      const https = require('https');
+      const options = {
+        hostname: 'api.notion.com',
+        path: '/v1/users/me',
+        method: 'GET',
+        headers: {
+          'Authorization': 'Bearer ' + token,
+          'Notion-Version': '2022-06-28'
+        },
+        timeout: 10000
+      };
+
+      const req = https.request(options, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          resolve({ statusCode: res.statusCode, body: data });
+        });
+      });
+
+      req.on('error', (e) => reject(e));
+      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+      req.end();
+    });
+
+    if (result.statusCode === 200) {
+      return { status: '🟢', detail: 'Notion API 连通', connected: true };
+    } else {
+      return { status: '🟡', detail: `Notion API 返回 ${result.statusCode}`, connected: false };
+    }
+  } catch (e) {
+    return { status: '🔴', detail: 'Notion API 请求失败: ' + e.message, connected: false };
+  }
+}
+
+// ━━━ 检查 GitHub API ━━━
+async function checkGitHubAPI() {
+  const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+
+  try {
+    const https = require('https');
+    const result = await new Promise((resolve, reject) => {
+      const options = {
+        hostname: 'api.github.com',
+        path: '/rate_limit',
+        method: 'GET',
+        headers: {
+          'User-Agent': 'skyeye-scanner',
+          'Accept': 'application/vnd.github.v3+json'
+        },
+        timeout: 10000
+      };
+
+      if (token) {
+        options.headers['Authorization'] = 'Bearer ' + token;
+      }
+
+      const req = https.request(options, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          resolve({ statusCode: res.statusCode, body: data });
+        });
+      });
+
+      req.on('error', (e) => reject(e));
+      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+      req.end();
+    });
+
+    if (result.statusCode === 200) {
+      try {
+        const rateData = JSON.parse(result.body);
+        const core = rateData.resources && rateData.resources.core;
+        return {
+          status: '🟢',
+          detail: 'GitHub API 连通',
+          connected: true,
+          rate_limit: core ? { remaining: core.remaining, limit: core.limit } : null
+        };
+      } catch (e) {
+        return { status: '🟢', detail: 'GitHub API 连通（无法解析配额）', connected: true };
+      }
+    } else {
+      return { status: '🟡', detail: `GitHub API 返回 ${result.statusCode}`, connected: false };
+    }
+  } catch (e) {
+    return { status: '🔴', detail: 'GitHub API 请求失败: ' + e.message, connected: false };
+  }
+}
+
+// ━━━ 检查服务器 SSH ━━━
+function checkServerSSH() {
+  const host = process.env.DEPLOY_HOST;
+  const user = process.env.DEPLOY_USER;
+  const key  = process.env.DEPLOY_KEY;
+
+  if (!host) {
+    return { status: '🟡', detail: 'DEPLOY_HOST 未设置', connected: false };
+  }
+
+  // SSH connectivity check would require actually connecting
+  // In CI, we just verify the credentials are available
+  const hasCredentials = !!(host && user && key);
+  return {
+    status: hasCredentials ? '🟡' : '🔴',
+    detail: hasCredentials
+      ? '服务器凭证已配置（SSH 连通性需运行时验证）'
+      : '服务器凭证不完整',
+    connected: null, // Cannot verify without actual SSH
+    credentials_present: hasCredentials
+  };
+}
+
+// ━━━ 主扫描 ━━━
+async function scanExternalBridges() {
+  const result = {
+    scan_time: new Date(now.getTime() + BEIJING_OFFSET_MS).toISOString().replace('T', ' ').slice(0, 19) + '+08:00',
+    notion_api: { status: '⏳', detail: '检查中...' },
+    github_api: { status: '⏳', detail: '检查中...' },
+    server_ssh: checkServerSSH(),
+    secrets: checkSecrets(),
+    // Summary
+    all_bridges_ok: false
+  };
+
+  // Parallel API checks
+  const [notionResult, githubResult] = await Promise.all([
+    checkNotionAPI().catch(e => ({ status: '🔴', detail: '检查异常: ' + e.message, connected: false })),
+    checkGitHubAPI().catch(e => ({ status: '🔴', detail: '检查异常: ' + e.message, connected: false }))
+  ]);
+
+  result.notion_api = notionResult;
+  result.github_api = githubResult;
+
+  // Summary
+  result.all_bridges_ok =
+    result.notion_api.status === '🟢' &&
+    result.github_api.status === '🟢' &&
+    result.secrets.complete;
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+scanExternalBridges();
diff --git a/scripts/skyeye/scan-structure.js b/scripts/skyeye/scan-structure.js
new file mode 100644
index 00000000..ef13d559
--- /dev/null
+++ b/scripts/skyeye/scan-structure.js
@@ -0,0 +1,204 @@
+// scripts/skyeye/scan-structure.js
+// 天眼·扫描模块B · 仓库结构完整性扫描
+//
+// 扫描内容：
+//   ① 核心目录是否存在
+//   ② 开发者沙盒目录（对照 routing-map.json）
+//   ③ 孤儿文件检测
+//   ④ 根目录是否干净
+//   ⑤ README.md 完整性
+//   ⑥ package.json 依赖一致性
+//
+// 输出：JSON → stdout
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '../..');
+
+const BEIJING_OFFSET_MS = 8 * 3600 * 1000;
+const now = new Date();
+
+// ━━━ 核心目录列表 ━━━
+const CORE_DIRS = [
+  '.github/persona-brain',
+  '.github/workflows',
+  'scripts',
+  'data',
+  'core',
+  'core/brain-wake',
+  'connectors',
+  'brain',
+  'docs',
+  'src'
+];
+
+// ━━━ 预期的根目录文件/目录 ━━━
+const EXPECTED_ROOT_ITEMS = [
+  '.github', '.git', '.gitignore', '.env',
+  'README.md', 'package.json', 'package-lock.json',
+  'node_modules',
+  'brain', 'core', 'connectors', 'scripts', 'data', 'docs', 'src',
+  'backend', 'frontend', 'modules', 'persona-studio', 'dingtalk-bot',
+  'persona-brain-db', 'openclaw',
+  'broadcasts', 'broadcasts-outbox', 'bulletin-board',
+  'syslog', 'syslog-processed', 'signal-log', 'collaboration-logs',
+  'reports', 'notification', 'dashboard', 'cloud-drive',
+  'config.js', 'config.json', 'routing-map.json', 'dev-status.json',
+  'broadcast-generator.js', 'server.js',
+  'dev', 'm10-cloud',
+  'guanghulab-main'
+];
+
+// ━━━ README Markers ━━━
+const README_MARKERS = [
+  'BINGSHUO_BULLETIN_START', 'BINGSHUO_BULLETIN_END',
+  'BINGSHUO_ALERT_START', 'BINGSHUO_ALERT_END',
+  'COLLABORATOR_BULLETIN_START', 'COLLABORATOR_BULLETIN_END',
+  'COLLABORATOR_ALERT_START', 'COLLABORATOR_ALERT_END'
+];
+
+// ━━━ 检查核心目录 ━━━
+function checkCoreDirs() {
+  const results = [];
+  let allOk = true;
+
+  for (const dir of CORE_DIRS) {
+    const dirPath = path.join(ROOT, dir);
+    const exists = fs.existsSync(dirPath);
+    if (!exists) allOk = false;
+    results.push({ path: dir, exists });
+  }
+
+  return { all_ok: allOk, dirs: results };
+}
+
+// ━━━ 检查根目录是否干净 ━━━
+function checkRootCleanliness() {
+  const orphans = [];
+  try {
+    const items = fs.readdirSync(ROOT);
+    for (const item of items) {
+      if (item.startsWith('.') && !EXPECTED_ROOT_ITEMS.includes(item) && item !== '.github' && item !== '.git' && item !== '.gitignore' && item !== '.env') {
+        orphans.push(item);
+      } else if (!item.startsWith('.') && !EXPECTED_ROOT_ITEMS.includes(item)) {
+        orphans.push(item);
+      }
+    }
+  } catch (e) {
+    return { clean: false, orphans: [], error: e.message };
+  }
+
+  return { clean: orphans.length === 0, orphans };
+}
+
+// ━━━ 检查 README.md 完整性 ━━━
+function checkReadme() {
+  const readmePath = path.join(ROOT, 'README.md');
+  try {
+    if (!fs.existsSync(readmePath)) {
+      return { exists: false, markers_ok: false, missing_markers: README_MARKERS };
+    }
+
+    const content = fs.readFileSync(readmePath, 'utf8');
+    const missingMarkers = [];
+    for (const marker of README_MARKERS) {
+      if (!content.includes(marker)) {
+        missingMarkers.push(marker);
+      }
+    }
+
+    return {
+      exists: true,
+      size: content.length,
+      markers_ok: missingMarkers.length === 0,
+      missing_markers: missingMarkers
+    };
+  } catch (e) {
+    return { exists: false, error: e.message };
+  }
+}
+
+// ━━━ 检查 package.json ━━━
+function checkPackageJson() {
+  const pkgPath = path.join(ROOT, 'package.json');
+  try {
+    if (!fs.existsSync(pkgPath)) {
+      return { exists: false };
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const hasNodeModules = fs.existsSync(path.join(ROOT, 'node_modules'));
+
+    return {
+      exists: true,
+      name: pkg.name,
+      version: pkg.version,
+      dep_count: Object.keys(pkg.dependencies || {}).length,
+      dev_dep_count: Object.keys(pkg.devDependencies || {}).length,
+      node_modules_exists: hasNodeModules,
+      has_scripts: Object.keys(pkg.scripts || {}).length > 0
+    };
+  } catch (e) {
+    return { exists: true, parse_error: e.message };
+  }
+}
+
+// ━━━ 检查开发者沙盒目录 ━━━
+function checkDevSandboxes() {
+  const devDir = path.join(ROOT, 'dev');
+  const results = [];
+
+  if (!fs.existsSync(devDir)) {
+    return { dev_dir_exists: false, sandboxes: [] };
+  }
+
+  try {
+    const items = fs.readdirSync(devDir);
+    for (const item of items) {
+      const itemPath = path.join(devDir, item);
+      const stat = fs.statSync(itemPath);
+      if (stat.isDirectory()) {
+        const files = fs.readdirSync(itemPath);
+        results.push({
+          name: item,
+          file_count: files.length,
+          has_readme: files.includes('README.md')
+        });
+      }
+    }
+  } catch (e) {
+    return { dev_dir_exists: true, error: e.message };
+  }
+
+  return { dev_dir_exists: true, sandboxes: results };
+}
+
+// ━━━ 主扫描 ━━━
+function scanStructure() {
+  const result = {
+    scan_time: new Date(now.getTime() + BEIJING_OFFSET_MS).toISOString().replace('T', ' ').slice(0, 19) + '+08:00',
+    core_dirs: checkCoreDirs(),
+    root_cleanliness: checkRootCleanliness(),
+    readme: checkReadme(),
+    package_json: checkPackageJson(),
+    dev_sandboxes: checkDevSandboxes(),
+    // Summary
+    core_dirs_ok: true,
+    orphan_files: 0,
+    missing_dirs: [],
+    readme_ok: true
+  };
+
+  // Compute summary
+  result.core_dirs_ok = result.core_dirs.all_ok;
+  result.missing_dirs = result.core_dirs.dirs.filter(d => !d.exists).map(d => d.path);
+  result.orphan_files = result.root_cleanliness.orphans ? result.root_cleanliness.orphans.length : 0;
+  result.readme_ok = result.readme.exists && result.readme.markers_ok;
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+scanStructure();
diff --git a/scripts/skyeye/scan-workflows.js b/scripts/skyeye/scan-workflows.js
new file mode 100644
index 00000000..06e063ff
--- /dev/null
+++ b/scripts/skyeye/scan-workflows.js
@@ -0,0 +1,241 @@
+// scripts/skyeye/scan-workflows.js
+// 天眼·扫描模块A · Workflow 健康度扫描
+//
+// 扫描内容：
+//   ① 所有 .yml 语法检查
+//   ② 最近 24h 运行结果（通过 /tmp/skyeye/recent-runs.json）
+//   ③ workflow 之间的触发冲突/死循环检测
+//   ④ cron 表达式合理性
+//   ⑤ workflow 基本结构验证
+//
+// 输出：JSON → stdout
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT   = path.resolve(__dirname, '../..');
+const WF_DIR = path.join(ROOT, '.github/workflows');
+
+const BEIJING_OFFSET_MS = 8 * 3600 * 1000;
+const now = new Date();
+
+// ━━━ YAML 基本语法检查 ━━━
+function checkYamlSyntax(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    // Basic checks: not empty, has 'name:', has 'on:', has 'jobs:'
+    const hasName = /^name\s*:/m.test(content);
+    const hasOn   = /^on\s*:/m.test(content) || /^on:/m.test(content) || /^"on"\s*:/m.test(content) || /^'on'\s*:/m.test(content);
+    const hasJobs = /^jobs\s*:/m.test(content);
+
+    const issues = [];
+    if (!hasName) issues.push('缺少 name 字段');
+    if (!hasOn)   issues.push('缺少 on 触发器');
+    if (!hasJobs) issues.push('缺少 jobs 定义');
+    if (content.includes('\t')) issues.push('包含 tab 字符（YAML 建议使用空格）');
+
+    return {
+      valid: issues.length === 0,
+      issues,
+      lines: content.split('\n').length
+    };
+  } catch (e) {
+    return { valid: false, issues: ['读取文件失败: ' + e.message], lines: 0 };
+  }
+}
+
+// ━━━ 提取 Workflow 元信息 ━━━
+function extractWorkflowMeta(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const meta = {};
+
+    // Name
+    const nameMatch = content.match(/^name\s*:\s*["']?(.+?)["']?\s*$/m);
+    meta.name = nameMatch ? nameMatch[1].trim() : path.basename(filePath);
+
+    // Triggers
+    meta.triggers = [];
+    if (/schedule\s*:/.test(content))          meta.triggers.push('schedule');
+    if (/push\s*:/.test(content))              meta.triggers.push('push');
+    if (/pull_request/.test(content))           meta.triggers.push('pull_request');
+    if (/workflow_dispatch/.test(content))      meta.triggers.push('workflow_dispatch');
+    if (/workflow_run/.test(content))           meta.triggers.push('workflow_run');
+    if (/issues\s*:/.test(content))            meta.triggers.push('issues');
+    if (/discussion/.test(content))            meta.triggers.push('discussion');
+
+    // Cron expressions
+    const cronMatches = content.match(/cron\s*:\s*['"](.+?)['"]/g);
+    meta.crons = cronMatches
+      ? cronMatches.map(c => c.match(/['"](.+?)['"]/)[1])
+      : [];
+
+    // Referenced secrets
+    const secretMatches = content.match(/secrets\.([A-Z_]+)/g);
+    meta.secrets = secretMatches
+      ? [...new Set(secretMatches.map(s => s.replace('secrets.', '')))]
+      : [];
+
+    // Uses git push?
+    meta.uses_git_push = /git\s+push/i.test(content);
+
+    // Commit prefix
+    const commitMatch = content.match(/git\s+commit\s+-m\s+["']([^\s"']+)/);
+    meta.commit_prefix = commitMatch ? commitMatch[1] : null;
+
+    return meta;
+  } catch (e) {
+    return { name: path.basename(filePath), triggers: [], crons: [], secrets: [], error: e.message };
+  }
+}
+
+// ━━━ 检测 Cron 冲突 ━━━
+function detectCronConflicts(workflows) {
+  const cronMap = {};
+  const conflicts = [];
+
+  for (const wf of workflows) {
+    for (const cron of (wf.meta.crons || [])) {
+      if (!cronMap[cron]) cronMap[cron] = [];
+      cronMap[cron].push(wf.file);
+    }
+  }
+
+  for (const [cron, files] of Object.entries(cronMap)) {
+    if (files.length > 1) {
+      conflicts.push({
+        type: 'cron_conflict',
+        cron,
+        workflows: files,
+        detail: `${files.length} 个 workflow 使用相同 cron: ${cron}`
+      });
+    }
+  }
+
+  return conflicts;
+}
+
+// ━━━ 检测潜在循环触发 ━━━
+function detectTriggerLoops(workflows) {
+  const loops = [];
+  const pushWorkflows = workflows.filter(w => w.meta.triggers.includes('push') && w.meta.uses_git_push);
+
+  for (const wf of pushWorkflows) {
+    // A workflow that triggers on push AND does git push could cause loops
+    // Unless it has proper guards (bot check, prefix check)
+    loops.push({
+      type: 'potential_loop',
+      workflow: wf.file,
+      detail: `${wf.file} 由 push 触发且执行 git push — 需确认有防循环保护`
+    });
+  }
+
+  return loops;
+}
+
+// ━━━ 解析最近运行结果 ━━━
+function parseRecentRuns() {
+  const runsFile = '/tmp/skyeye/recent-runs.json';
+  try {
+    if (!fs.existsSync(runsFile)) return { available: false, runs: [] };
+    const runs = JSON.parse(fs.readFileSync(runsFile, 'utf8'));
+    return { available: true, runs };
+  } catch (e) {
+    return { available: false, runs: [], error: e.message };
+  }
+}
+
+// ━━━ 主扫描 ━━━
+function scanWorkflows() {
+  const result = {
+    scan_time: new Date(now.getTime() + BEIJING_OFFSET_MS).toISOString().replace('T', ' ').slice(0, 19) + '+08:00',
+    total_workflows: 0,
+    healthy: 0,
+    issues: [],
+    workflow_map: [],
+    cron_conflicts: [],
+    potential_loops: []
+  };
+
+  // 1. 扫描所有 workflow 文件
+  let files = [];
+  try {
+    files = fs.readdirSync(WF_DIR).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+  } catch (e) {
+    result.issues.push({ file: WF_DIR, type: 'dir_error', detail: '无法读取 workflows 目录: ' + e.message });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  result.total_workflows = files.length;
+
+  for (const file of files) {
+    const filePath = path.join(WF_DIR, file);
+    const syntax = checkYamlSyntax(filePath);
+    const meta = extractWorkflowMeta(filePath);
+
+    const entry = {
+      file,
+      name: meta.name,
+      triggers: meta.triggers,
+      crons: meta.crons,
+      secrets: meta.secrets,
+      uses_git_push: meta.uses_git_push,
+      syntax_ok: syntax.valid,
+      status: syntax.valid ? '✅' : '❌',
+      last_run: null
+    };
+
+    if (syntax.valid) {
+      result.healthy++;
+    } else {
+      result.issues.push({
+        file,
+        type: 'syntax_error',
+        detail: syntax.issues.join('; ')
+      });
+    }
+
+    result.workflow_map.push(entry);
+  }
+
+  // 2. 整合最近运行结果
+  const recentRuns = parseRecentRuns();
+  if (recentRuns.available) {
+    for (const run of recentRuns.runs) {
+      const entry = result.workflow_map.find(w => w.name === run.name);
+      if (entry) {
+        entry.last_run = run.createdAt;
+        if (run.conclusion === 'failure') {
+          entry.status = '❌';
+          if (!result.issues.find(i => i.file === entry.file && i.type === 'run_failure')) {
+            result.issues.push({
+              file: entry.file,
+              type: 'run_failure',
+              detail: `最近运行失败 · ${run.createdAt}`
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // 3. 检测 Cron 冲突
+  result.cron_conflicts = detectCronConflicts(
+    result.workflow_map.map(w => ({ file: w.file, meta: { crons: w.crons } }))
+  );
+
+  // 4. 检测循环触发风险
+  result.potential_loops = detectTriggerLoops(
+    result.workflow_map.map(w => ({
+      file: w.file,
+      meta: { triggers: w.triggers, uses_git_push: w.uses_git_push }
+    }))
+  );
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+scanWorkflows();
diff --git a/scripts/skyeye/skyeye-main.js b/scripts/skyeye/skyeye-main.js
new file mode 100644
index 00000000..30e422e4
--- /dev/null
+++ b/scripts/skyeye/skyeye-main.js
@@ -0,0 +1,92 @@
+// scripts/skyeye/skyeye-main.js
+// 天眼·主编排器
+//
+// 本地运行入口：node scripts/skyeye/skyeye-main.js
+// 在 CI 中各模块由 workflow steps 分别调用
+// 本地调试时可通过此脚本串联执行所有模块
+
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+
+const SKYEYE_DIR = '/tmp/skyeye';
+const SCRIPTS_DIR = path.resolve(__dirname);
+
+const BEIJING_OFFSET_MS = 8 * 3600 * 1000;
+const now = new Date();
+const bjTime = new Date(now.getTime() + BEIJING_OFFSET_MS).toISOString()
+  .replace('T', ' ').slice(0, 19) + '+08:00';
+
+// ━━━ 执行模块 ━━━
+function runModule(scriptName, outputFile) {
+  const scriptPath = path.join(SCRIPTS_DIR, scriptName);
+  console.log(`\n🔄 运行: ${scriptName}`);
+  console.log('─'.repeat(50));
+
+  try {
+    const output = execSync(`node "${scriptPath}"`, {
+      cwd: path.resolve(__dirname, '../..'),
+      env: { ...process.env },
+      encoding: 'utf8',
+      timeout: 60000
+    });
+
+    // Save output to file
+    if (outputFile) {
+      const outputPath = path.join(SKYEYE_DIR, outputFile);
+      fs.writeFileSync(outputPath, output);
+      console.log(`💾 输出保存到: ${outputFile}`);
+    }
+
+    return true;
+  } catch (e) {
+    console.error(`❌ ${scriptName} 执行失败: ${e.message}`);
+    if (e.stdout) console.log(e.stdout);
+    return false;
+  }
+}
+
+// ━━━ 主流程 ━━━
+function main() {
+  console.log('');
+  console.log('🦅 ═══════════════════════════════════════════');
+  console.log('   天眼系统 · 全局俯瞰 + 自动诊断 + 修复驱动');
+  console.log(`   时间: ${bjTime}`);
+  console.log('═══════════════════════════════════════════════');
+
+  // 确保输出目录
+  fs.mkdirSync(SKYEYE_DIR, { recursive: true });
+
+  const results = {};
+
+  // Phase 2: 全局扫描
+  console.log('\n🦅 Phase 2 · 全局扫描');
+  results.workflows = runModule('scan-workflows.js', 'workflow-health.json');
+  results.structure = runModule('scan-structure.js', 'structure-health.json');
+  results.brain     = runModule('scan-brain-health.js', 'brain-health.json');
+  results.bridges   = runModule('scan-external-bridges.js', 'bridge-health.json');
+
+  // Phase 3: 诊断
+  console.log('\n🔬 Phase 3 · 诊断');
+  results.diagnosis = runModule('diagnose.js', 'diagnosis.json');
+
+  // Phase 4: 修复
+  console.log('\n🔧 Phase 4 · 修复 Agent');
+  results.repair = runModule('repair-agent.js', 'repair-result.json');
+
+  // Phase 6: 报告
+  console.log('\n📋 Phase 6 · 全局健康报告');
+  results.report = runModule('report-generator.js', null);
+
+  // 汇总
+  console.log('\n═══════════════════════════════════════════');
+  console.log('🦅 天眼运行完毕');
+  const passed = Object.values(results).filter(r => r).length;
+  const total = Object.keys(results).length;
+  console.log(`   模块: ${passed}/${total} 成功`);
+  console.log('═══════════════════════════════════════════\n');
+}
+
+main();
diff --git a/scripts/skyeye/sync-to-notion.js b/scripts/skyeye/sync-to-notion.js
new file mode 100644
index 00000000..12cdd0b5
--- /dev/null
+++ b/scripts/skyeye/sync-to-notion.js
@@ -0,0 +1,154 @@
+// scripts/skyeye/sync-to-notion.js
+// 天眼·报告同步到 Notion
+//
+// 将天眼全局健康报告同步到 Notion 数据库
+// 如果 NOTION_TOKEN 未设置则优雅跳过
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const https = require('https');
+
+const SKYEYE_DIR = '/tmp/skyeye';
+const NOTION_TOKEN = process.env.NOTION_TOKEN;
+const SYSLOG_DB_ID = process.env.NOTION_SYSLOG_DB_ID;
+
+const NOTION_TITLE_MAX = 100;
+const NOTION_CONTENT_MAX = 2000;
+
+// ━━━ 安全读取 JSON ━━━
+function readJSON(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+// ━━━ Notion API 调用 ━━━
+function notionRequest(apiPath, body) {
+  return new Promise((resolve, reject) => {
+    if (!NOTION_TOKEN) {
+      return reject(new Error('NOTION_TOKEN 未设置'));
+    }
+
+    const postData = JSON.stringify(body);
+    const options = {
+      hostname: 'api.notion.com',
+      path: apiPath,
+      method: 'POST',
+      headers: {
+        'Authorization': 'Bearer ' + NOTION_TOKEN,
+        'Notion-Version': '2022-06-28',
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData)
+      },
+      timeout: 15000
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve({ statusCode: res.statusCode, body: data });
+        } else {
+          reject(new Error(`Notion API ${res.statusCode}: ${data.substring(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Notion API timeout')); });
+    req.write(postData);
+    req.end();
+  });
+}
+
+// ━━━ 格式化报告为文本 ━━━
+function formatReportText(report) {
+  if (!report) return '天眼报告数据缺失';
+
+  const lines = [
+    `🦅 天眼报告 ${report.report_id}`,
+    `整体健康: ${report.overall_health}`,
+    `时间: ${report.timestamp}`,
+    '',
+    `🧠 核心大脑: ${report.brain_status.integrity}`,
+    `📋 Workflow: ${report.workflow_health.healthy}/${report.workflow_health.total} 健康`,
+    `📂 仓库结构: ${report.structure_health.core_dirs_ok ? '✅' : '❌'}`,
+    `🌉 外部桥接: Notion=${report.bridge_health.notion_api} GitHub=${report.bridge_health.github_api}`,
+    '',
+    `🔬 诊断: ${report.diagnosis.total_issues} 个问题`,
+    `   自动修复: ${report.diagnosis.auto_fixed}`,
+    `   需人工: ${report.diagnosis.needs_human}`,
+    `   观察中: ${report.diagnosis.watching}`
+  ];
+
+  if (report.repairs_applied.length > 0) {
+    lines.push('', '🔧 已执行修复:');
+    for (const r of report.repairs_applied) {
+      lines.push(`   • ${r}`);
+    }
+  }
+
+  if (report.tickets_created.length > 0) {
+    lines.push('', '📨 生成工单:');
+    for (const t of report.tickets_created) {
+      lines.push(`   • ${t}`);
+    }
+  }
+
+  return lines.join('\n').substring(0, NOTION_CONTENT_MAX);
+}
+
+// ━━━ 主同步流程 ━━━
+async function syncToNotion() {
+  console.log('📡 天眼·Notion 同步启动');
+
+  if (!NOTION_TOKEN) {
+    console.log('⚠️ NOTION_TOKEN 未设置，跳过 Notion 同步');
+    return;
+  }
+
+  if (!SYSLOG_DB_ID) {
+    console.log('⚠️ NOTION_SYSLOG_DB_ID 未设置，跳过 Notion 同步');
+    return;
+  }
+
+  const report = readJSON(path.join(SKYEYE_DIR, 'full-report.json'));
+  if (!report) {
+    console.log('⚠️ 天眼报告不存在，跳过 Notion 同步');
+    return;
+  }
+
+  const title = `🦅 天眼报告 ${report.report_id} · ${report.overall_health}`;
+  const content = formatReportText(report);
+
+  try {
+    await notionRequest('/v1/pages', {
+      parent: { database_id: SYSLOG_DB_ID },
+      properties: {
+        '标题': {
+          title: [{ type: 'text', text: { content: title.substring(0, NOTION_TITLE_MAX) } }]
+        },
+        '接收时间': { date: { start: new Date().toISOString() } },
+        '推送方': {
+          rich_text: [{ type: 'text', text: { content: '天眼系统' } }]
+        },
+        '文件内容': {
+          rich_text: [{ type: 'text', text: { content } }]
+        }
+      }
+    });
+
+    console.log('✅ 天眼报告已同步到 Notion');
+  } catch (e) {
+    console.error('⚠️ Notion 同步失败:', e.message);
+    // 不阻断流程
+  }
+}
+
+syncToNotion();