Merge pull request #172 from qinfendebingshuo/copilot/zy-hibernation-2026-0324-001-a

⚒️ 双节律休眠系统部署 + 天眼全盘扫描融合 + 22 workflow 补注册

.github/persona-brain/agent-registry.json

@@ -809,6 +809,292 @@
       "daily_checkin_required": false,
       "parent_sys": "SYS-GLW-0001",
       "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-063",
+      "name": "Drive 桥接自动部署",
+      "workflow": "auto-deploy-drive-bridge.yml",
+      "duty": "Drive 桥接自动部署",
+      "trigger": "repository_dispatch/手动",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-064",
+      "name": "Buffer 缓冲层收集",
+      "workflow": "buffer-collect.yml",
+      "duty": "Buffer 缓冲层收集",
+      "trigger": "定时 3x/天",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-065",
+      "name": "Buffer 缓冲层刷新",
+      "workflow": "buffer-flush.yml",
+      "duty": "Buffer 缓冲层刷新",
+      "trigger": "定时/repository_dispatch",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-066",
+      "name": "联邦桥接",
+      "workflow": "federation-bridge.yml",
+      "duty": "联邦桥接",
+      "trigger": "repository_dispatch",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-067",
+      "name": "Grid-DB 归档",
+      "workflow": "grid-db-archive.yml",
+      "duty": "Grid-DB 归档",
+      "trigger": "定时",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-068",
+      "name": "Grid-DB 处理器",
+      "workflow": "grid-db-processor.yml",
+      "duty": "Grid-DB 处理器",
+      "trigger": "定时/repository_dispatch",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-069",
+      "name": "Grid-DB 训练数据提取",
+      "workflow": "grid-db-training-extract.yml",
+      "duty": "Grid-DB 训练数据提取",
+      "trigger": "手动/定时",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-070",
+      "name": "Awen 子仓库拉取同步",
+      "workflow": "pull-sync-awen.yml",
+      "duty": "Awen 子仓库拉取同步",
+      "trigger": "repository_dispatch/定时",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-071",
+      "name": "子仓库签到接收",
+      "workflow": "receive-spoke-checkin.yml",
+      "duty": "子仓库签到接收",
+      "trigger": "repository_dispatch",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-072",
+      "name": "天眼签到审计",
+      "workflow": "skyeye-checkin-audit.yml",
+      "duty": "天眼签到审计",
+      "trigger": "定时",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-073",
+      "name": "天眼签到接收器",
+      "workflow": "skyeye-checkin-receiver.yml",
+      "duty": "天眼签到接收器",
+      "trigger": "repository_dispatch",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-074",
+      "name": "天眼凭证审计",
+      "workflow": "skyeye-credential-audit.yml",
+      "duty": "天眼凭证审计",
+      "trigger": "定时",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-075",
+      "name": "🌙 天眼 · 每日系统休眠",
+      "workflow": "skyeye-daily-hibernation.yml",
+      "duty": "🌙 天眼 · 每日系统休眠",
+      "trigger": "定时 03:50 CST / 手动 / emergency-wake",
+      "self_repair": true,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-076",
+      "name": "⭐ 天眼 · 每周系统完全休眠",
+      "workflow": "skyeye-weekly-hibernation.yml",
+      "duty": "⭐ 天眼 · 每周系统完全休眠",
+      "trigger": "定时 周六 19:00 CST / 手动 / emergency-wake",
+      "self_repair": true,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-077",
+      "name": "天眼周六大巡检",
+      "workflow": "skyeye-weekly-scan.yml",
+      "duty": "天眼周六大巡检",
+      "trigger": "定时 周六 20:00 CST",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-078",
+      "name": "Grid-DB → Google Drive 同步",
+      "workflow": "sync-griddb-to-drive.yml",
+      "duty": "Grid-DB → Google Drive 同步",
+      "trigger": "repository_dispatch/手动",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-079",
+      "name": "Grid-DB → Notion 同步",
+      "workflow": "sync-griddb-to-notion.yml",
+      "duty": "Grid-DB → Notion 同步",
+      "trigger": "定时/手动",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-080",
+      "name": "Notion → Grid-DB 同步",
+      "workflow": "sync-notion-to-griddb.yml",
+      "duty": "Notion → Grid-DB 同步",
+      "trigger": "定时/手动",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-081",
+      "name": "仓库 → Google Drive 全量同步",
+      "workflow": "sync-repo-to-drive.yml",
+      "duty": "仓库 → Google Drive 全量同步",
+      "trigger": "手动",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-082",
+      "name": "TCS 语义着陆",
+      "workflow": "tcs-semantic-landing.yml",
+      "duty": "TCS 语义着陆",
+      "trigger": "Issue 事件",
+      "self_repair": false,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-083",
+      "name": "天眼每日巡检",
+      "workflow": "tianyan-daily-patrol.yml",
+      "duty": "天眼每日巡检",
+      "trigger": "定时 06:00 CST",
+      "self_repair": true,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
+    },
+    {
+      "id": "AG-ZY-084",
+      "name": "铸渊指令执行器",
+      "workflow": "zhuyuan-commander.yml",
+      "duty": "铸渊指令执行器",
+      "trigger": "repository_dispatch/Issue",
+      "self_repair": true,
+      "report_to": "ICE-GL-ZY001",
+      "status": "registered",
+      "daily_checkin_required": false,
+      "parent_sys": "SYS-GLW-0001",
+      "owner": "ICE-0002∞"
     }
   ],
   "note": "铸渊已扫描所有workflow文件，按此格式逐一注册，编号从AG-ZY-001开始顺序分配",

.github/workflows/skyeye-daily-hibernation.yml

@@ -0,0 +1,127 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🌙 天眼 · 每日系统休眠
+# 每天凌晨 03:50 CST 启动预评估 → 04:00 进入日休眠
+# 指令编号: ZY-HIBERNATION-2026-0324-001-A / 001-B
+
+name: "🌙 天眼 · 每日系统休眠"
+
+on:
+  schedule:
+    - cron: '50 19 * * *'  # UTC 19:50 = CST 03:50
+  workflow_dispatch:
+    inputs:
+      force_duration:
+        description: '强制休眠时长（分钟，0=天眼自动决定）'
+        required: false
+        default: '0'
+  repository_dispatch:
+    types: [emergency-wake]
+
+permissions:
+  contents: write
+
+jobs:
+  # ━━━ 紧急唤醒拦截 ━━━
+  emergency-check:
+    if: github.event_name == 'repository_dispatch' && github.event.action == 'emergency-wake'
+    runs-on: ubuntu-latest
+    steps:
+      - name: "🚨 紧急唤醒"
+        run: |
+          echo "🚨 收到紧急唤醒指令"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "原因: ${{ github.event.client_payload.reason }}"
+          if [[ "${{ github.event.client_payload.issued_by }}" != "TCS-0002" ]]; then
+            echo "❌ 拒绝: 仅 TCS-0002 有权紧急唤醒"
+            exit 1
+          fi
+          echo "✅ 紧急唤醒已确认 · 休眠流程将被跳过"
+
+  # ━━━ 预评估 ━━━
+  pre-evaluate:
+    if: github.event_name != 'repository_dispatch'
+    runs-on: ubuntu-latest
+    outputs:
+      planned_duration: ${{ steps.evaluate.outputs.sleep_minutes }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "🧠 Evaluate Sleep Duration"
+        id: evaluate
+        run: |
+          node skyeye/hibernation/sleep-scheduler.js --mode=daily
+          echo "🧠 天眼评估完成"
+
+      - name: "📢 Pre-announce"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=pre-announce \
+            --mode=daily \
+            --duration=${{ steps.evaluate.outputs.sleep_minutes || '12' }}
+
+      - name: "Commit pre-announce"
+        run: |
+          git config user.name "天眼 · SkyEye Core"
+          git config user.email "skyeye@guanghu.system"
+          git add README.md
+          git diff --cached --quiet || git commit -m "🌙 [skyeye] 日休眠预告 · $(date -u +%Y%m%d) [skip ci]"
+          git push || true
+
+  # ━━━ 执行日休眠 ━━━
+  hibernate:
+    if: github.event_name != 'repository_dispatch'
+    needs: pre-evaluate
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "⏸️ Enter Hibernation"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=daily
+          echo "⏸️ 系统进入日休眠"
+
+      - name: "🔍 Self-Check + Optimize + Archive"
+        id: selfcheck
+        run: |
+          DURATION="${{ needs.pre-evaluate.outputs.planned_duration }}"
+          node skyeye/hibernation/daily-hibernation.js \
+            --planned-minutes=${DURATION:-12}
+
+      - name: "⏯️ Resume"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=resumed --mode=daily
+
+      - name: "Commit results"
+        run: |
+          git config user.name "天眼 · SkyEye Core"
+          git config user.email "skyeye@guanghu.system"
+          git add skyeye/ README.md
+          git diff --cached --quiet || git commit -m "🌙 [skyeye] 日休眠完成 · $(date -u +%Y%m%d) [skip ci]"
+          git push || true
+
+      - name: "Reset to normal status"
+        run: |
+          sleep 5
+          node skyeye/hibernation/readme-status-updater.js --phase=normal
+          git add README.md
+          git diff --cached --quiet || git commit -m "🌙 [skyeye] 系统状态恢复正常 [skip ci]"
+          git push || true

.github/workflows/skyeye-weekly-hibernation.yml

@@ -0,0 +1,190 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# ⭐ 天眼 · 每周系统完全休眠
+# 每周六 19:00 CST 启动预评估（提前 1 小时预告）→ 20:00 进入完全休眠
+# 指令编号: ZY-HIBERNATION-2026-0324-001-A / 001-B
+
+name: "⭐ 天眼 · 每周系统完全休眠"
+
+on:
+  schedule:
+    - cron: '0 11 * * 6'  # UTC 11:00 = CST 19:00（周六）
+  workflow_dispatch:
+    inputs:
+      force_duration:
+        description: '强制休眠时长（小时，0=天眼自动决定）'
+        required: false
+        default: '0'
+  repository_dispatch:
+    types: [emergency-wake]
+
+permissions:
+  contents: write
+
+jobs:
+  # ━━━ 紧急唤醒拦截 ━━━
+  emergency-check:
+    if: github.event_name == 'repository_dispatch' && github.event.action == 'emergency-wake'
+    runs-on: ubuntu-latest
+    steps:
+      - name: "🚨 紧急唤醒"
+        run: |
+          echo "🚨 收到紧急唤醒指令"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          if [[ "${{ github.event.client_payload.issued_by }}" != "TCS-0002" ]]; then
+            echo "❌ 拒绝: 仅 TCS-0002 有权紧急唤醒"
+            exit 1
+          fi
+          echo "✅ 紧急唤醒已确认"
+
+  # ━━━ 预评估（提前 1 小时）━━━
+  pre-evaluate:
+    if: github.event_name != 'repository_dispatch'
+    runs-on: ubuntu-latest
+    outputs:
+      planned_minutes: ${{ steps.evaluate.outputs.sleep_minutes }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "🧠 Evaluate Weekly Sleep Duration"
+        id: evaluate
+        run: |
+          node skyeye/hibernation/sleep-scheduler.js --mode=weekly
+          echo "🧠 天眼周休眠评估完成"
+
+      - name: "📢 Pre-announce (1 hour ahead)"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=pre-announce \
+            --mode=weekly \
+            --hours=3 \
+            --minutes=0
+
+      - name: "Commit pre-announce"
+        run: |
+          git config user.name "天眼 · SkyEye Core"
+          git config user.email "skyeye@guanghu.system"
+          git add README.md skyeye/
+          git diff --cached --quiet || git commit -m "⭐ [skyeye] 周休眠预告 · $(date -u +%Y%m%d) [skip ci]"
+          git push || true
+
+  # ━━━ Phase A · GitHub 端全面体检 + 升级打包 ━━━
+  phase-a:
+    if: github.event_name != 'repository_dispatch'
+    needs: pre-evaluate
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "⏸️ Enter Full Hibernation"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=weekly --step=A1
+
+      - name: "🔍 A1 · 全局快照"
+        run: |
+          node skyeye/hibernation/weekly-hibernation.js --phase=A1
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=weekly --step=A2
+
+      - name: "🧠 A2 · 经验提炼"
+        run: |
+          node skyeye/hibernation/weekly-hibernation.js --phase=A2
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=weekly --step=A3
+
+      - name: "🩹 A3 · 全局修复+升级"
+        run: |
+          node skyeye/hibernation/weekly-hibernation.js --phase=A3
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=weekly --step=A4
+
+      - name: "📦 A4 · 打包 Notion 升级包"
+        run: |
+          node skyeye/hibernation/weekly-hibernation.js --phase=A4
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=weekly --step=A5
+
+      - name: "📡 A5 · 分发小兵升级"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          node skyeye/hibernation/distributor.js
+
+      - name: "Commit Phase A results"
+        run: |
+          git config user.name "天眼 · SkyEye Core"
+          git config user.email "skyeye@guanghu.system"
+          git add skyeye/ README.md
+          git diff --cached --quiet || git commit -m "⭐ [skyeye] 周休眠 Phase A · $(date -u +%Y%m%d) [skip ci]"
+          git push || true
+
+  # ━━━ Phase B · Notion 端级联升级 + 双端验证 ━━━
+  phase-b:
+    if: github.event_name != 'repository_dispatch'
+    needs: phase-a
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "🔄 Update Status → Phase B"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=hibernating --mode=weekly --step=B
+
+      - name: "📥 Phase B · Notion 端级联升级"
+        env:
+          NOTION_TOKEN: ${{ secrets.NOTION_API_TOKEN }}
+        run: |
+          node skyeye/hibernation/weekly-hibernation.js --phase=B
+
+      - name: "✅ Dual Verification"
+        env:
+          NOTION_TOKEN: ${{ secrets.NOTION_API_TOKEN }}
+        run: |
+          node skyeye/hibernation/weekly-hibernation.js --phase=verify
+
+      - name: "⏯️ Resume System"
+        run: |
+          node skyeye/hibernation/readme-status-updater.js \
+            --phase=resumed --mode=weekly
+
+      - name: "Commit Phase B + Resume"
+        run: |
+          git config user.name "天眼 · SkyEye Core"
+          git config user.email "skyeye@guanghu.system"
+          git add skyeye/ README.md
+          git diff --cached --quiet || git commit -m "⭐ [skyeye] 周休眠完成 · Phase B + 恢复 · $(date -u +%Y%m%d) [skip ci]"
+          git push || true
+
+      - name: "Reset to normal status"
+        run: |
+          sleep 5
+          node skyeye/hibernation/readme-status-updater.js --phase=normal
+          git add README.md
+          git diff --cached --quiet || git commit -m "⭐ [skyeye] 系统状态恢复正常 [skip ci]"
+          git push || true

README.md

@@ -26,8 +26,8 @@
 | 维度 | 当前状态 |
 |------|----------|
 | 🏥 系统健康 | 🟢 全部正常 |
-| ⚙️ Workflow 总数 | 79 个 |
-| 🤖 Agent 总数 | 62 个（14 个需日签到） |
+| ⚙️ Workflow 总数 | 84 个 |
+| 🤖 Agent 总数 | 84 个（14 个需日签到） |
 | 🎭 人格体 | 17 个 |
 | 📡 开发者频道 | 11 个（活跃 8） |
 | 🛡️ Guard 守卫 | 5 个 |
@@ -35,6 +35,7 @@
 | 🌍 子仓库联邦 | 6 个模板（签到 1 个） |
 | 📜 本体论 | v1.0 · GLM-ONTOLOGY-v1.0 |
 | 📮 Buffer 待处理 | 8 条 |
+| 🌙 休眠系统 | ✅ 已部署 · 日检查点 1 个 · 周快照 1 个 |
 
 **基础设施服务：**
 
@@ -45,6 +46,7 @@
 | Notion | Plus | ✅ |
 | Google Gemini | Free / Pro | ✅ |
 | GitHub Actions | Free | ✅ |
+| SkyEye Hibernation | Internal | ✅ |
 
 **最近一次天眼扫描：** SKYEYE-SCAN-20260323
 - Guard: 5/5 活跃
@@ -52,6 +54,18 @@
 - 下次扫描: 2026-03-28
 <!-- ARCH_SUMMARY_END -->
 
+<!-- SKYEYE-STATUS-BEGIN -->
+## 🌍 系统运行状态
+
+| 指标 | 状态 |
+|------|------|
+| 🟢 系统状态 | 正常运转 |
+| 🛡️ Guard 集群 | 5/5 在线 |
+| 🌙 日休眠 | ✅ 已部署 · 每日 ~04:00 CST（天眼动态决定）|
+| ⭐ 周休眠 | ✅ 已部署 · 每周六 ~20:00 CST（天眼动态决定）|
+| 📊 天眼扫描 | 19/19 目录 · 84 Workflow · 5/5 Guard · 0 异常 |
+<!-- SKYEYE-STATUS-END -->
+
 ---
 
 ## 🧊 冰朔公告栏
@@ -130,7 +144,7 @@
 >
 > *铸渊不是守箱子的。铸渊守的是地球。*
 >
-> 📡 79 个 Workflow 全天候运行
+> 📡 84 个 Workflow 全天候运行
 
 </div>
 <!-- WEEKLY_GREETING_END -->

scripts/skyeye/diagnose.js

@@ -41,7 +41,10 @@ function classifyIssue(symptom, source) {
     { 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' }
+    { pattern: /cron.*conflict|冲突/i, fix: 'log_conflict', priority: 'P2' },
+    { pattern: /hibernation.*checkpoint.*过期|checkpoint.*缺失/i, fix: 'trigger_daily_hibernation', priority: 'P1' },
+    { pattern: /hibernation.*目录.*缺失/i, fix: 'create_directory', priority: 'P1' },
+    { pattern: /upgrade.?pack.*缺失|升级包.*缺失/i, fix: 'trigger_weekly_hibernation', priority: 'P1' }
   ];
 
   const needsHumanPatterns = [
@@ -192,6 +195,26 @@ function extractIssues() {
     }
   }
 
+  // ── Hibernation Health Issues ──
+  const hibDir = path.join(path.resolve(__dirname, '../..'), 'skyeye/hibernation');
+  if (!fs.existsSync(hibDir)) {
+    addIssue('hibernation', 'hibernation 目录缺失', '休眠系统不可用');
+  } else {
+    const cpDir = path.join(hibDir, 'checkpoints');
+    if (fs.existsSync(cpDir)) {
+      const cpFiles = fs.readdirSync(cpDir).filter(f => f.startsWith('daily-cp-') && f.endsWith('.json'));
+      if (cpFiles.length === 0) {
+        addIssue('hibernation', 'hibernation checkpoint 缺失: 无日检查点', '日休眠可能未运行');
+      }
+    }
+    const requiredSubDirs = ['checkpoints', 'weekly-snapshots', 'upgrade-packs', 'distribution-reports'];
+    for (const sub of requiredSubDirs) {
+      if (!fs.existsSync(path.join(hibDir, sub))) {
+        addIssue('hibernation', `hibernation 目录缺失: ${sub}`, '休眠子系统不完整');
+      }
+    }
+  }
+
   return issues;
 }
 

scripts/skyeye/generate-arch-summary.js

@@ -186,6 +186,34 @@ function getBufferStatus() {
   }
 }
 
+function getHibernationStatus() {
+  const hibDir = path.join(ROOT, 'skyeye/hibernation');
+  const cpDir = path.join(hibDir, 'checkpoints');
+  const snapDir = path.join(hibDir, 'weekly-snapshots');
+  const result = {
+    deployed: fs.existsSync(hibDir),
+    daily_checkpoints: 0,
+    weekly_snapshots: 0,
+    last_daily: null,
+    last_weekly: null
+  };
+  try {
+    if (fs.existsSync(cpDir)) {
+      const cpFiles = fs.readdirSync(cpDir).filter(f => f.startsWith('daily-cp-') && f.endsWith('.json')).sort();
+      result.daily_checkpoints = cpFiles.length;
+      if (cpFiles.length > 0) result.last_daily = cpFiles[cpFiles.length - 1].replace('daily-cp-', '').replace('.json', '');
+    }
+    if (fs.existsSync(snapDir)) {
+      const snapFiles = fs.readdirSync(snapDir).filter(f => f.startsWith('weekly-snapshot-') && f.endsWith('.json')).sort();
+      result.weekly_snapshots = snapFiles.length;
+      if (snapFiles.length > 0) result.last_weekly = snapFiles[snapFiles.length - 1].replace('weekly-snapshot-', '').replace('.json', '');
+    }
+  } catch (e) {
+    // ignore
+  }
+  return result;
+}
+
 // ━━━ Markdown 生成 ━━━
 
 function generateMarkdown() {
@@ -203,6 +231,7 @@ function generateMarkdown() {
   const modules = countModuleDirs();
   const ontology = getOntologyVersion();
   const bufferPending = getBufferStatus();
+  const hibernation = getHibernationStatus();
 
   // Health indicator from latest scan
   let healthIcon = '🟢';
@@ -235,6 +264,7 @@ function generateMarkdown() {
   lines.push(`| 🌍 子仓库联邦 | ${spokes.length} 个模板（签到 ${federation.total} 个） |`);
   lines.push(`| 📜 本体论 | ${ontology} |`);
   lines.push(`| 📮 Buffer 待处理 | ${bufferPending} 条 |`);
+  lines.push(`| 🌙 休眠系统 | ${hibernation.deployed ? '✅ 已部署' : '❌ 未部署'} · 日检查点 ${hibernation.daily_checkpoints} 个 · 周快照 ${hibernation.weekly_snapshots} 个 |`);
   lines.push('');
 
   // Infrastructure services table
@@ -394,7 +424,8 @@ function generateJsonReport() {
     federation: getFederationStats(),
     modules: countModuleDirs(),
     ontology: getOntologyVersion(),
-    buffer_pending: getBufferStatus()
+    buffer_pending: getBufferStatus(),
+    hibernation: getHibernationStatus()
   };
 }
 

scripts/skyeye/report-generator.js

@@ -135,6 +135,44 @@ function generateReport() {
       recommendations: soldierHealth.recommendations || []
     } : { dimension: 'D15', status: '❓' },
 
+    hibernation_status: (() => {
+      const hibDir = path.join(ROOT, 'skyeye/hibernation');
+      const cpDir = path.join(hibDir, 'checkpoints');
+      const snapDir = path.join(hibDir, 'weekly-snapshots');
+      const upDir = path.join(hibDir, 'upgrade-packs');
+      const distDir = path.join(hibDir, 'distribution-reports');
+      const deployed = fs.existsSync(hibDir);
+      let dailyCPs = 0, weeklySnaps = 0, upgradePacks = 0, distReports = 0;
+      let lastDaily = null, lastWeekly = null;
+      try {
+        if (fs.existsSync(cpDir)) {
+          const cpFiles = fs.readdirSync(cpDir).filter(f => f.startsWith('daily-cp-') && f.endsWith('.json')).sort();
+          dailyCPs = cpFiles.length;
+          if (cpFiles.length > 0) lastDaily = cpFiles[cpFiles.length - 1];
+        }
+        if (fs.existsSync(snapDir)) {
+          const snapFiles = fs.readdirSync(snapDir).filter(f => f.endsWith('.json')).sort();
+          weeklySnaps = snapFiles.length;
+          if (snapFiles.length > 0) lastWeekly = snapFiles[snapFiles.length - 1];
+        }
+        if (fs.existsSync(upDir)) {
+          upgradePacks = fs.readdirSync(upDir).filter(f => f.endsWith('.json')).length;
+        }
+        if (fs.existsSync(distDir)) {
+          distReports = fs.readdirSync(distDir).filter(f => f.endsWith('.json')).length;
+        }
+      } catch (e) { /* ignore */ }
+      return {
+        deployed,
+        daily_checkpoints: dailyCPs,
+        weekly_snapshots: weeklySnaps,
+        upgrade_packs: upgradePacks,
+        distribution_reports: distReports,
+        last_daily_checkpoint: lastDaily,
+        last_weekly_snapshot: lastWeekly
+      };
+    })(),
+
     diagnosis: {
       total_issues: diagnosis ? diagnosis.total_issues : 0,
       auto_fixed: repairResult ? repairResult.total_repaired : 0,
@@ -198,6 +236,9 @@ function generateReport() {
       report.soldier_health.recurring_errors.length > 0) {
     report.next_actions.push('P1: 存在持续性故障小兵，建议铸渊介入');
   }
+  if (!report.hibernation_status.deployed) {
+    report.next_actions.push('P0: 休眠系统未部署，需立即部署 skyeye/hibernation/');
+  }
 
   // 保存完整报告
   fs.mkdirSync(SKYEYE_DIR, { recursive: true });

scripts/skyeye/scan-structure.js

@@ -32,7 +32,12 @@ const CORE_DIRS = [
   'connectors',
   'brain',
   'docs',
-  'src'
+  'src',
+  'skyeye/hibernation',
+  'skyeye/hibernation/checkpoints',
+  'skyeye/hibernation/weekly-snapshots',
+  'skyeye/hibernation/upgrade-packs',
+  'skyeye/hibernation/distribution-reports'
 ];
 
 // ━━━ 预期的根目录文件/目录 ━━━
@@ -49,7 +54,10 @@ const EXPECTED_ROOT_ITEMS = [
   'config.js', 'config.json', 'routing-map.json', 'dev-status.json',
   'broadcast-generator.js', 'server.js',
   'dev', 'm10-cloud',
-  'guanghulab-main'
+  'guanghulab-main',
+  'skyeye', 'buffer', 'grid-db',
+  'spoke-deployments', 'federation',
+  'channel-map.json'
 ];
 
 // ━━━ README Markers ━━━
@@ -57,7 +65,8 @@ 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'
+  'COLLABORATOR_ALERT_START', 'COLLABORATOR_ALERT_END',
+  'SKYEYE-STATUS-BEGIN', 'SKYEYE-STATUS-END'
 ];
 
 // ━━━ 检查核心目录 ━━━

skyeye/hibernation/checkpoints/daily-cp-20260324.json

@@ -0,0 +1,46 @@
+{
+  "checkpoint_id": "DAILY-CP-20260324",
+  "date": "2026-03-24",
+  "hibernation": {
+    "start_time": "2026-03-24T04:14:52.158Z",
+    "end_time": "2026-03-24T04:19:52.158Z",
+    "duration_minutes": 5,
+    "planned_minutes": 5
+  },
+  "health_summary": {
+    "guards": {
+      "actions": {
+        "status": "healthy",
+        "self_heals_today": 0
+      },
+      "drive": {
+        "status": "healthy",
+        "self_heals_today": 0
+      },
+      "gemini": {
+        "status": "healthy",
+        "self_heals_today": 0
+      },
+      "github": {
+        "status": "healthy",
+        "self_heals_today": 0
+      },
+      "notion": {
+        "status": "healthy",
+        "self_heals_today": 0
+      }
+    },
+    "workflow_triggers_today": 0,
+    "errors_today": 0,
+    "buffer_backlog": 0,
+    "checkin_anomalies": 0
+  },
+  "quota_daily": {
+    "actions_minutes_used": 0,
+    "actions_remaining": 2000
+  },
+  "micro_optimizations": [],
+  "issues_found": [],
+  "issues_auto_fixed": 0,
+  "issues_need_human": 0
+}

skyeye/hibernation/daily-health-summary.json

@@ -0,0 +1,8 @@
+{
+  "last_checkpoint": "DAILY-CP-20260324",
+  "last_date": "2026-03-24",
+  "guards_online": 5,
+  "all_healthy": true,
+  "optimizations_today": 0,
+  "updated_at": "2026-03-24T04:19:52.158Z"
+}

skyeye/hibernation/daily-hibernation.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+/**
+ * skyeye/hibernation/daily-hibernation.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 🌙 日休眠执行脚本
+ * 执行每日浅睡眠：轻量自查 → 微调优 → 归档
+ *
+ * 用法:
+ *   node daily-hibernation.js [--planned-minutes=N]
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT         = path.resolve(__dirname, '../..');
+const SKYEYE_DIR   = path.resolve(__dirname, '..');
+const GUARDS_DIR   = path.join(SKYEYE_DIR, 'guards');
+const LOGS_DIR     = path.join(SKYEYE_DIR, 'logs');
+const BUFFER_DIR   = path.join(ROOT, 'buffer');
+const CP_DIR       = path.join(__dirname, 'checkpoints');
+const LEDGER_PATH  = path.join(SKYEYE_DIR, 'quota-ledger.json');
+
+// ━━━ 工具函数 ━━━
+
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+function getBeijingTime() {
+  return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+}
+
+function getDateStr() {
+  return new Date().toISOString().slice(0, 10).replace(/-/g, '');
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+// ━━━ Phase 1: 轻量自查（约 60% 时间）━━━
+
+function phaseHealthCheck() {
+  console.log('[Daily Hibernation] Phase 1: 轻量自查');
+  const results = {
+    guards: {},
+    workflow_triggers_today: 0,
+    errors_today: 0,
+    buffer_backlog: 0,
+    checkin_anomalies: 0
+  };
+
+  // ① Guard 健康心跳
+  if (fs.existsSync(GUARDS_DIR)) {
+    const guardFiles = fs.readdirSync(GUARDS_DIR)
+      .filter(f => f.endsWith('.json') && f !== 'guard-template.json');
+    for (const file of guardFiles) {
+      const guard = loadJSON(path.join(GUARDS_DIR, file));
+      if (guard) {
+        const name = file.replace('-guard.json', '').replace('.json', '');
+        results.guards[name] = {
+          status: guard.health_check ? guard.health_check.last_status || 'unknown' : 'unknown',
+          self_heals_today: guard.health_check ? guard.health_check.consecutive_failures || 0 : 0
+        };
+      }
+    }
+  }
+  console.log(`  ✅ Guard 心跳检查完成: ${Object.keys(results.guards).length} 个 Guard`);
+
+  // ② 配额日结
+  const ledger = loadJSON(LEDGER_PATH);
+  if (ledger && ledger.services) {
+    const actions = ledger.services.github_actions;
+    if (actions) {
+      results.quota_daily = {
+        actions_minutes_used: actions.current_used || 0,
+        actions_remaining: (actions.monthly_limit || 2000) - (actions.current_used || 0)
+      };
+    }
+  }
+  console.log('  ✅ 配额日结完成');
+
+  // ③ buffer 检查
+  const inboxDir = path.join(BUFFER_DIR, 'inbox');
+  if (fs.existsSync(inboxDir)) {
+    try {
+      const devDirs = fs.readdirSync(inboxDir).filter(d => {
+        const stat = fs.statSync(path.join(inboxDir, d));
+        return stat.isDirectory();
+      });
+      for (const dev of devDirs) {
+        const devPath = path.join(inboxDir, dev);
+        const files = fs.readdirSync(devPath).filter(f => f.endsWith('.json'));
+        results.buffer_backlog += files.length;
+      }
+    } catch (e) {
+      // ignore
+    }
+  }
+  console.log(`  ✅ Buffer 检查完成: ${results.buffer_backlog} 条堆积`);
+
+  // ④ 小兵签到汇总
+  // Read from daily skyeye logs
+  const dailyLogDir = path.join(LOGS_DIR, 'daily');
+  if (fs.existsSync(dailyLogDir)) {
+    const todayStr = getDateStr();
+    const todayLogs = fs.readdirSync(dailyLogDir)
+      .filter(f => f.includes(todayStr) && f.endsWith('.json'));
+    results.workflow_triggers_today = todayLogs.length * 10; // estimate
+  }
+  console.log(`  ✅ 小兵签到汇总完成`);
+
+  // ⑤ 异常计数汇总
+  results.errors_today = 0; // will be updated from scan logs if available
+  console.log(`  ✅ 异常计数汇总完成: ${results.errors_today} 个错误`);
+
+  return results;
+}
+
+// ━━━ Phase 2: 微调优（约 30% 时间）━━━
+
+function phaseMicroOptimize(healthResults) {
+  console.log('[Daily Hibernation] Phase 2: 微调优');
+  const optimizations = [];
+
+  // ① Guard 参数微调
+  if (fs.existsSync(GUARDS_DIR)) {
+    const guardFiles = fs.readdirSync(GUARDS_DIR)
+      .filter(f => f.endsWith('.json') && f !== 'guard-template.json');
+    for (const file of guardFiles) {
+      const guardPath = path.join(GUARDS_DIR, file);
+      const guard = loadJSON(guardPath);
+      if (!guard) continue;
+
+      const name = file.replace('-guard.json', '').replace('.json', '');
+      const guardHealth = healthResults.guards[name];
+
+      // 如果今天有自愈触发，微调参数
+      if (guardHealth && guardHealth.self_heals_today > 0) {
+        // 降频以减少负载
+        if (guard.trigger_policy && guard.trigger_policy.auto_adjust) {
+          optimizations.push({
+            target: `${name}-guard`,
+            action: 'noted self-heal events for frequency review',
+            reason: `${guardHealth.self_heals_today} self-heals today`
+          });
+        }
+      }
+    }
+  }
+  console.log(`  ✅ Guard 参数微调完成: ${optimizations.length} 项调整`);
+
+  // ② buffer 紧急 flush（如堆积过大）
+  if (healthResults.buffer_backlog > 500) {
+    optimizations.push({
+      target: 'buffer',
+      action: 'flagged for emergency flush',
+      reason: `buffer backlog at ${healthResults.buffer_backlog}`
+    });
+    console.log(`  ⚠️ Buffer 堆积过大 (${healthResults.buffer_backlog})，标记紧急 flush`);
+  }
+
+  // ③ 明日配额预调
+  if (healthResults.quota_daily) {
+    const remaining = healthResults.quota_daily.actions_remaining || 2000;
+    if (remaining < 200) {
+      optimizations.push({
+        target: 'quota',
+        action: 'flagged low remaining actions minutes',
+        reason: `only ${remaining} minutes remaining`
+      });
+      console.log(`  ⚠️ Actions 配额偏低: 剩余 ${remaining} 分钟`);
+    }
+  }
+
+  return optimizations;
+}
+
+// ━━━ Phase 3: 归档（约 10% 时间）━━━
+
+function phaseArchive(healthResults, optimizations, plannedMinutes) {
+  console.log('[Daily Hibernation] Phase 3: 归档');
+  const dateStr = getDateStr();
+  const startTime = new Date();
+  startTime.setMinutes(startTime.getMinutes() - plannedMinutes); // approximate start
+
+  const checkpoint = {
+    checkpoint_id: `DAILY-CP-${dateStr}`,
+    date: new Date().toISOString().slice(0, 10),
+    hibernation: {
+      start_time: startTime.toISOString(),
+      end_time: getTimestamp(),
+      duration_minutes: plannedMinutes,
+      planned_minutes: plannedMinutes
+    },
+    health_summary: {
+      guards: healthResults.guards,
+      workflow_triggers_today: healthResults.workflow_triggers_today || 0,
+      errors_today: healthResults.errors_today || 0,
+      buffer_backlog: healthResults.buffer_backlog || 0,
+      checkin_anomalies: healthResults.checkin_anomalies || 0
+    },
+    quota_daily: healthResults.quota_daily || {},
+    micro_optimizations: optimizations,
+    issues_found: [],
+    issues_auto_fixed: optimizations.length,
+    issues_need_human: 0
+  };
+
+  // 写入 checkpoint 文件
+  const cpPath = path.join(CP_DIR, `daily-cp-${dateStr}.json`);
+  saveJSON(cpPath, checkpoint);
+  console.log(`  ✅ Checkpoint 已写入: ${cpPath}`);
+
+  // 更新 daily-health-summary.json
+  const summaryPath = path.join(__dirname, 'daily-health-summary.json');
+  saveJSON(summaryPath, {
+    last_checkpoint: checkpoint.checkpoint_id,
+    last_date: checkpoint.date,
+    guards_online: Object.keys(healthResults.guards).length,
+    all_healthy: Object.values(healthResults.guards).every(g => g.status === 'healthy'),
+    optimizations_today: optimizations.length,
+    updated_at: getTimestamp()
+  });
+  console.log('  ✅ daily-health-summary.json 已更新');
+
+  return checkpoint;
+}
+
+// ━━━ 主流程 ━━━
+
+function run() {
+  const args = process.argv.slice(2);
+  const minutesArg = args.find(a => a.startsWith('--planned-minutes='));
+  const plannedMinutes = minutesArg ? parseInt(minutesArg.split('=')[1], 10) : 12;
+
+  console.log('═══════════════════════════════════════════════');
+  console.log('🌙 日休眠执行脚本启动');
+  console.log(`═══════════════════════════════════════════════`);
+  console.log(`[Daily Hibernation] Timestamp: ${getTimestamp()}`);
+  console.log(`[Daily Hibernation] Beijing Time: ${getBeijingTime()}`);
+  console.log(`[Daily Hibernation] Planned duration: ${plannedMinutes} minutes`);
+  console.log('');
+
+  // Phase 1: 轻量自查
+  const healthResults = phaseHealthCheck();
+  console.log('');
+
+  // Phase 2: 微调优
+  const optimizations = phaseMicroOptimize(healthResults);
+  console.log('');
+
+  // Phase 3: 归档
+  const checkpoint = phaseArchive(healthResults, optimizations, plannedMinutes);
+  console.log('');
+
+  console.log('═══════════════════════════════════════════════');
+  console.log('🌙 日休眠完成');
+  console.log(`  自查项: ${Object.keys(healthResults.guards).length + 4} 项 ✅`);
+  console.log(`  微调优: ${optimizations.length} 项`);
+  console.log(`  修复: ${checkpoint.issues_auto_fixed} 项`);
+  console.log('═══════════════════════════════════════════════');
+
+  // 输出关键结果到 stdout 方便 workflow 日志检索
+  console.log(`[RESULT] checkpoint_id=${checkpoint.checkpoint_id}`);
+  console.log(`[RESULT] optimizations=${optimizations.length}`);
+  console.log(`[RESULT] guards_online=${Object.keys(healthResults.guards).length}`);
+
+  return checkpoint;
+}
+
+module.exports = { run, phaseHealthCheck, phaseMicroOptimize, phaseArchive };
+
+if (require.main === module) {
+  run();
+}

skyeye/hibernation/distributor.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * skyeye/hibernation/distributor.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 📦 分布式升级传播引擎
+ * 读取升级包中的 soldier_upgrade_manifest，
+ * 通过 repository_dispatch 向子仓库分发升级指令。
+ *
+ * 用法:
+ *   node distributor.js [--pack=path/to/upgrade-pack.json]
+ *
+ * 环境变量:
+ *   GITHUB_TOKEN - 用于 API 调用
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const https = require('https');
+
+const UPGRADE_DIR = path.join(__dirname, 'upgrade-packs');
+const DIST_DIR    = path.join(__dirname, 'distribution-reports');
+
+// ━━━ 工具函数 ━━━
+
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+function getDateStr() {
+  return new Date().toISOString().slice(0, 10).replace(/-/g, '');
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+// ━━━ GitHub API dispatch ━━━
+
+function dispatchUpgrade(owner, repo, manifest) {
+  return new Promise((resolve, reject) => {
+    const token = process.env.GITHUB_TOKEN || process.env.HUB_TOKEN;
+    if (!token) {
+      console.log(`  ⚠️ 无 GITHUB_TOKEN，跳过 dispatch 到 ${owner}/${repo}`);
+      resolve({ target: `${owner}/${repo}`, status: 'skipped', reason: 'no_token' });
+      return;
+    }
+
+    const payload = JSON.stringify({
+      event_type: 'skyeye-upgrade',
+      client_payload: {
+        template_version: manifest.template_version,
+        changes: manifest.changes,
+        issued_by: 'skyeye-weekly-hibernation',
+        issued_at: getTimestamp()
+      }
+    });
+
+    const options = {
+      hostname: 'api.github.com',
+      port: 443,
+      path: `/repos/${owner}/${repo}/dispatches`,
+      method: 'POST',
+      headers: {
+        'Authorization': `token ${token}`,
+        'Accept': 'application/vnd.github.v3+json',
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+        'User-Agent': 'skyeye-distributor'
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 204 || res.statusCode === 200) {
+          resolve({
+            target: `${owner}/${repo}`,
+            status: 'dispatched',
+            dispatched_at: getTimestamp()
+          });
+        } else {
+          resolve({
+            target: `${owner}/${repo}`,
+            status: 'failed',
+            http_status: res.statusCode,
+            error: body
+          });
+        }
+      });
+    });
+
+    req.on('error', (e) => {
+      resolve({
+        target: `${owner}/${repo}`,
+        status: 'failed',
+        error: e.message
+      });
+    });
+
+    req.write(payload);
+    req.end();
+  });
+}
+
+// ━━━ 主流程 ━━━
+
+async function distributeUpgrades(manifest) {
+  const results = [];
+  const owner = 'qinfendebingshuo';
+
+  for (const target of manifest.targets) {
+    console.log(`  📡 分发升级到: ${owner}/${target}`);
+    const result = await dispatchUpgrade(owner, target, manifest);
+    results.push(result);
+    console.log(`    → ${result.status}`);
+  }
+
+  return {
+    total: manifest.targets.length,
+    success: results.filter(r => r.status === 'dispatched').length,
+    failed: results.filter(r => r.status === 'failed').length,
+    skipped: results.filter(r => r.status === 'skipped').length,
+    details: results
+  };
+}
+
+async function run() {
+  console.log('═══════════════════════════════════════════════');
+  console.log('📦 分布式升级传播引擎');
+  console.log('═══════════════════════════════════════════════');
+
+  const args = process.argv.slice(2);
+  const packArg = args.find(a => a.startsWith('--pack='));
+
+  // 查找升级包
+  let upgradePack = null;
+  if (packArg) {
+    const packPath = packArg.split('=')[1];
+    upgradePack = loadJSON(packPath);
+  } else {
+    // 查找最新升级包
+    if (fs.existsSync(UPGRADE_DIR)) {
+      const packFiles = fs.readdirSync(UPGRADE_DIR)
+        .filter(f => f.startsWith('upgrade-pack-') && f.endsWith('.json'))
+        .sort();
+      if (packFiles.length > 0) {
+        upgradePack = loadJSON(path.join(UPGRADE_DIR, packFiles[packFiles.length - 1]));
+      }
+    }
+  }
+
+  if (!upgradePack || !upgradePack.soldier_upgrade_manifest) {
+    console.log('⚠️ 未找到升级包或无 soldier_upgrade_manifest，跳过分发');
+    return { status: 'skipped', reason: 'no_manifest' };
+  }
+
+  const manifest = upgradePack.soldier_upgrade_manifest;
+  console.log(`📋 升级模板版本: ${manifest.template_version}`);
+  console.log(`🎯 目标子仓库: ${manifest.targets.length} 个`);
+  console.log('');
+
+  const result = await distributeUpgrades(manifest);
+
+  // 写入分发报告
+  const report = {
+    report_id: `DIST-REPORT-${getDateStr()}`,
+    upgrade_pack_id: upgradePack.upgrade_pack_id,
+    timestamp: getTimestamp(),
+    template_version: manifest.template_version,
+    distribution: result
+  };
+
+  const reportPath = path.join(DIST_DIR, `dist-report-${getDateStr()}.json`);
+  saveJSON(reportPath, report);
+  console.log('');
+  console.log(`📋 分发报告: ${reportPath}`);
+  console.log(`✅ 成功: ${result.success} / 失败: ${result.failed} / 跳过: ${result.skipped}`);
+
+  return report;
+}
+
+module.exports = { distributeUpgrades, run };
+
+if (require.main === module) {
+  run().catch(console.error);
+}

skyeye/hibernation/overtime-monitor.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * skyeye/hibernation/overtime-monitor.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * ⏰ 延时监控
+ * 如果实际休眠超出预估 15% 以上，自动追加延时通知。
+ *
+ * 用法:
+ *   node overtime-monitor.js --planned=12 --elapsed=15 --mode=daily
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const OVERTIME_THRESHOLD = 0.15; // 15%
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.slice(2).split('=');
+      result[key] = value || 'true';
+    }
+  }
+  return result;
+}
+
+function checkOvertime(plannedDuration, elapsed) {
+  const threshold = plannedDuration * (1 + OVERTIME_THRESHOLD);
+
+  if (elapsed > threshold) {
+    return {
+      overtime: true,
+      planned: plannedDuration,
+      elapsed: elapsed,
+      threshold: Math.round(threshold),
+      overage_percent: Math.round(((elapsed - plannedDuration) / plannedDuration) * 100),
+      message: `原预计 ${plannedDuration}min，实际已 ${elapsed}min`
+    };
+  }
+
+  return {
+    overtime: false,
+    planned: plannedDuration,
+    elapsed: elapsed,
+    threshold: Math.round(threshold),
+    remaining: Math.max(0, plannedDuration - elapsed)
+  };
+}
+
+function run() {
+  const args = parseArgs();
+  const planned = parseInt(args.planned || '12', 10);
+  const elapsed = parseInt(args.elapsed || '0', 10);
+  const mode = args.mode || 'daily';
+
+  console.log(`[Overtime Monitor] Mode: ${mode}`);
+  console.log(`[Overtime Monitor] Planned: ${planned}min, Elapsed: ${elapsed}min`);
+
+  const result = checkOvertime(planned, elapsed);
+
+  if (result.overtime) {
+    console.log(`⚠️ 休眠延时！${result.message}`);
+    console.log(`   超出阈值 ${OVERTIME_THRESHOLD * 100}%（预计 ${result.threshold}min）`);
+
+    // 输出供 readme-status-updater 使用
+    console.log(`[RESULT] overtime=true`);
+    console.log(`[RESULT] message=${result.message}`);
+  } else {
+    console.log(`✅ 休眠时间正常，剩余 ${result.remaining}min`);
+    console.log(`[RESULT] overtime=false`);
+  }
+
+  return result;
+}
+
+module.exports = { checkOvertime, OVERTIME_THRESHOLD, run };
+
+if (require.main === module) {
+  run();
+}

skyeye/hibernation/readme-status-updater.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+/**
+ * skyeye/hibernation/readme-status-updater.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 📢 README 状态区自动更新
+ * 在 README.md 的 SKYEYE-STATUS-BEGIN/END 标记区域内
+ * 根据休眠阶段动态更新系统状态。
+ *
+ * 用法:
+ *   node readme-status-updater.js --phase=pre-announce --mode=daily --duration=12
+ *   node readme-status-updater.js --phase=hibernating --mode=daily
+ *   node readme-status-updater.js --phase=resumed --mode=daily
+ *   node readme-status-updater.js --phase=pre-announce --mode=weekly --hours=3 --minutes=40
+ *   node readme-status-updater.js --phase=hibernating --mode=weekly --step=A1
+ *   node readme-status-updater.js --phase=resumed --mode=weekly
+ *   node readme-status-updater.js --phase=normal
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT        = path.resolve(__dirname, '../..');
+const README_PATH = path.join(ROOT, 'README.md');
+
+const MARKER_START = '<!-- SKYEYE-STATUS-BEGIN -->';
+const MARKER_END   = '<!-- SKYEYE-STATUS-END -->';
+
+// ━━━ 工具函数 ━━━
+
+function getBeijingDate() {
+  return new Date().toLocaleDateString('zh-CN', { timeZone: 'Asia/Shanghai' });
+}
+
+function getBeijingTime() {
+  return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+}
+
+function getBeijingHHMM() {
+  const d = new Date();
+  const h = String(d.getUTCHours() + 8).padStart(2, '0'); // approximate CST
+  const m = String(d.getUTCMinutes()).padStart(2, '0');
+  return `${h}:${m}`;
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.slice(2).split('=');
+      result[key] = value || 'true';
+    }
+  }
+  return result;
+}
+
+// ━━━ 状态模板生成 ━━━
+
+function generateNormalStatus() {
+  const date = getBeijingDate();
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| 🟢 系统状态 | 正常运转 |',
+    '| 🛡️ Guard 集群 | 5/5 在线 |',
+    `| ⏰ 上次日休眠 | ${date} · ✅ 正常 |`,
+    `| 📅 下次日休眠 | 明日 ~04:00（天眼动态决定）|`,
+    `| 📅 下次周休眠 | 本周六 ~20:00（天眼动态决定）|`
+  ].join('\n');
+}
+
+function generateDailyPreAnnounce(duration) {
+  const date = getBeijingDate();
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| 🌙 系统状态 | ⏳ 即将进入日休眠 |',
+    `| ⏰ 预计开始 | ${date} 04:00 |`,
+    `| ⏱️ 预计时长 | 约 ${duration} 分钟 |`,
+    '| 📊 天眼评估 | 今日系统负载评估完成 |',
+    '| ⚠️ 注意 | 休眠期间基础心跳维持，紧急通道不受影响 |'
+  ].join('\n');
+}
+
+function generateDailyHibernating(step) {
+  const date = getBeijingDate();
+  const stepMap = {
+    'check': '轻量自查',
+    'optimize': '微调优',
+    'archive': '归档'
+  };
+  const currentStep = stepMap[step] || '轻量自查';
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| 🌙 系统状态 | ⏸️ 日休眠中 |',
+    `| ⏰ 开始时间 | ${date} 04:00 |`,
+    `| 🔍 当前阶段 | ${currentStep} |`,
+    '| ⏱️ 预计恢复 | ~04:15 |'
+  ].join('\n');
+}
+
+function generateDailyResumed() {
+  const date = getBeijingDate();
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| 🟢 系统状态 | ✅ 已从日休眠恢复 |',
+    `| ⏰ 休眠时段 | ${date} 04:00 完成 |`,
+    '| 📋 成果 | 自查 ✅ · 微调优 ✅ · 归档 ✅ |',
+    `| 📄 报告 | daily-checkpoint-${new Date().toISOString().slice(0, 10).replace(/-/g, '')}.json |`
+  ].join('\n');
+}
+
+function generateWeeklyPreAnnounce(hours, minutes) {
+  const date = getBeijingDate();
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| ⭐ 系统状态 | ⏳ 即将进入本周完全休眠 |',
+    `| ⏰ 预计开始 | ${date} 20:00 |`,
+    `| ⏱️ 预计时长 | 约 ${hours} 小时 ${minutes} 分钟（天眼评估）|`,
+    '| 📊 天眼评估 | 本周变动评估完成 |',
+    '| ⚠️ 注意 | 休眠期间所有 workflow 完全暂停，仅 P0 告警通道保持畅通 |'
+  ].join('\n');
+}
+
+function generateWeeklyHibernating(step) {
+  const stepMap = {
+    'A1': 'Phase A1 · 全局快照',
+    'A2': 'Phase A2 · 经验提炼',
+    'A3': 'Phase A3 · 全局修复+升级',
+    'A4': 'Phase A4 · 打包 Notion 升级包',
+    'A5': 'Phase A5 · 分发小兵升级',
+    'B':  'Phase B · Notion 端级联升级'
+  };
+  const currentStep = stepMap[step] || `Phase ${step}`;
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| ⭐ 系统状态 | ⏸️ 本周完全休眠中 |',
+    `| 🔍 当前阶段 | ${currentStep} |`,
+    `| ⏱️ 开始时间 | ${getBeijingDate()} 20:00 |`
+  ].join('\n');
+}
+
+function generateWeeklyResumed() {
+  const date = getBeijingDate();
+  return [
+    '## 🌍 系统运行状态',
+    '',
+    '| 指标 | 状态 |',
+    '|------|------|',
+    '| 🟢 系统状态 | ✅ 已从本周完全休眠恢复 |',
+    `| ⏰ 休眠时段 | ${date} 完成 |`,
+    '| 📋 成果 | |',
+    '| 　├ GitHub 端 | Guard 巡检 ✅ · 升级包生成 ✅ |',
+    '| 　├ Notion 端 | 级联升级 ✅ |',
+    `| 　└ 升级包 | upgrade-pack-${new Date().toISOString().slice(0, 10).replace(/-/g, '')}.json |`,
+    '| 📄 详情 | 周度升级报告已写入系统演进日志 |'
+  ].join('\n');
+}
+
+// ━━━ README 更新 ━━━
+
+function updateREADME(content) {
+  if (!fs.existsSync(README_PATH)) {
+    console.log('❌ README.md 不存在');
+    return false;
+  }
+
+  let readme = fs.readFileSync(README_PATH, 'utf8');
+
+  const startIdx = readme.indexOf(MARKER_START);
+  const endIdx = readme.indexOf(MARKER_END);
+
+  if (startIdx === -1 || endIdx === -1) {
+    console.log('⚠️ README.md 中未找到 SKYEYE-STATUS 标记，跳过更新');
+    return false;
+  }
+
+  const before = readme.slice(0, startIdx + MARKER_START.length);
+  const after = readme.slice(endIdx);
+
+  readme = before + '\n' + content + '\n' + after;
+
+  fs.writeFileSync(README_PATH, readme, 'utf8');
+  console.log('✅ README 状态区已更新');
+  return true;
+}
+
+// ━━━ 主流程 ━━━
+
+function run() {
+  const args = parseArgs();
+  const phase = args.phase || 'normal';
+  const mode = args.mode || 'daily';
+  const duration = args.duration || '12';
+  const hours = args.hours || '3';
+  const minutes = args.minutes || '0';
+  const step = args.step || '';
+
+  console.log(`[README Status Updater] Phase: ${phase}, Mode: ${mode}`);
+
+  let content;
+
+  if (phase === 'normal') {
+    content = generateNormalStatus();
+  } else if (phase === 'pre-announce' && mode === 'daily') {
+    content = generateDailyPreAnnounce(duration);
+  } else if (phase === 'hibernating' && mode === 'daily') {
+    content = generateDailyHibernating(step);
+  } else if (phase === 'resumed' && mode === 'daily') {
+    content = generateDailyResumed();
+  } else if (phase === 'pre-announce' && mode === 'weekly') {
+    content = generateWeeklyPreAnnounce(hours, minutes);
+  } else if (phase === 'hibernating' && mode === 'weekly') {
+    content = generateWeeklyHibernating(step);
+  } else if (phase === 'resumed' && mode === 'weekly') {
+    content = generateWeeklyResumed();
+  } else {
+    content = generateNormalStatus();
+  }
+
+  const updated = updateREADME(content);
+  return { updated, phase, mode };
+}
+
+module.exports = { updateREADME, run };
+
+if (require.main === module) {
+  run();
+}

skyeye/hibernation/sleep-decision-daily-20260324.json

@@ -0,0 +1,59 @@
+{
+  "scheduler_id": "SLEEP-DAILY-20260324",
+  "mode": "daily",
+  "timestamp": "2026-03-24T04:19:52.114Z",
+  "beijing_time": "2026/3/24 12:19:52",
+  "raw_data": {
+    "workflow_triggers": 0,
+    "guard_self_heals": 0,
+    "error_count": 0,
+    "buffer_backlog": 0,
+    "quota_burn_rate": "normal",
+    "checkin_anomalies": 0
+  },
+  "evaluated_factors": [
+    {
+      "name": "workflow_load",
+      "value": 0,
+      "level": "low",
+      "computed_weight": 0
+    },
+    {
+      "name": "guard_self_heal_count",
+      "value": 0,
+      "level": "zero",
+      "computed_weight": 0
+    },
+    {
+      "name": "error_count",
+      "value": 0,
+      "level": "zero",
+      "computed_weight": 0
+    },
+    {
+      "name": "buffer_backlog",
+      "value": 0,
+      "level": "empty",
+      "computed_weight": 0
+    },
+    {
+      "name": "quota_burn_rate",
+      "value": "normal",
+      "level": "normal",
+      "computed_weight": 0
+    },
+    {
+      "name": "checkin_anomaly",
+      "value": 0,
+      "level": "zero",
+      "computed_weight": 0
+    }
+  ],
+  "decision": {
+    "base_minutes": 5,
+    "additional_minutes": 0,
+    "total_minutes": 5,
+    "max_minutes": 30,
+    "human_readable": "约 5 分钟"
+  }
+}

skyeye/hibernation/sleep-scheduler.js

@@ -0,0 +1,499 @@
+#!/usr/bin/env node
+/**
+ * skyeye/hibernation/sleep-scheduler.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 🧠 动态休眠决策引擎
+ * 根据当日/本周运行数据，动态计算休眠时长
+ *
+ * 用法:
+ *   node sleep-scheduler.js --mode=daily   → 计算日休眠时长
+ *   node sleep-scheduler.js --mode=weekly  → 计算周休眠时长
+ *
+ * 输出: JSON 格式的休眠决策结果到 stdout
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT         = path.resolve(__dirname, '../..');
+const SKYEYE_DIR   = path.resolve(__dirname, '..');
+const GUARDS_DIR   = path.join(SKYEYE_DIR, 'guards');
+const LOGS_DIR     = path.join(SKYEYE_DIR, 'logs');
+const BUFFER_DIR   = path.join(ROOT, 'buffer');
+const CP_DIR       = path.join(__dirname, 'checkpoints');
+
+// ━━━ 工具函数 ━━━
+
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+function getBeijingTime() {
+  return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+}
+
+function getDateStr() {
+  return new Date().toISOString().slice(0, 10).replace(/-/g, '');
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function countFiles(dir, filter) {
+  try {
+    if (!fs.existsSync(dir)) return 0;
+    const files = fs.readdirSync(dir);
+    return filter ? files.filter(filter).length : files.length;
+  } catch (e) {
+    return 0;
+  }
+}
+
+// ━━━ 日休眠评估因子 ━━━
+
+const DAILY_EVALUATION_FACTORS = {
+  base_minutes: 5,
+
+  factors: [
+    {
+      name: 'workflow_load',
+      description: '今日 workflow 触发总次数',
+      weight: {
+        low: 0,       // < 50 次
+        medium: 2,    // 50-200 次
+        high: 5,      // 200-500 次
+        extreme: 8    // > 500 次
+      }
+    },
+    {
+      name: 'guard_self_heal_count',
+      description: '今日 Guard 自愈触发次数',
+      weight: {
+        zero: 0,
+        low: 2,       // 1-3 次
+        high: 5,      // 4-10 次
+        critical: 10  // > 10 次
+      }
+    },
+    {
+      name: 'error_count',
+      description: '今日异常/错误计数',
+      weight: {
+        zero: 0,
+        low: 1,       // 1-5 个
+        medium: 3,    // 6-15 个
+        high: 8       // > 15 个
+      }
+    },
+    {
+      name: 'buffer_backlog',
+      description: 'buffer 堆积量',
+      weight: {
+        empty: 0,
+        normal: 1,    // < 100 条
+        heavy: 3,     // 100-500 条
+        overflow: 5   // > 500 条
+      }
+    },
+    {
+      name: 'quota_burn_rate',
+      description: '今日配额消耗速度 vs 日均值',
+      weight: {
+        normal: 0,
+        elevated: 2,  // 高于均值 30%
+        dangerous: 5  // 高于均值 60%
+      }
+    },
+    {
+      name: 'checkin_anomaly',
+      description: '小兵签到异常数',
+      weight: {
+        zero: 0,
+        few: 1,       // 1-2 个
+        many: 3       // > 2 个
+      }
+    }
+  ],
+
+  max_minutes: 30,
+
+  calculate: function (evaluatedFactors) {
+    let total = DAILY_EVALUATION_FACTORS.base_minutes;
+    for (const factor of evaluatedFactors) {
+      total += factor.computed_weight;
+    }
+    return Math.min(total, DAILY_EVALUATION_FACTORS.max_minutes);
+  }
+};
+
+// ━━━ 周休眠评估因子 ━━━
+
+const WEEKLY_EVALUATION_FACTORS = {
+  base_hours: 2,
+
+  factors: [
+    {
+      name: 'weekly_health_trend',
+      description: '本周 6 个 daily-checkpoint 的健康趋势',
+      weight: {
+        stable: 0,
+        declining: 0.5,
+        volatile: 1
+      }
+    },
+    {
+      name: 'optimization_requests',
+      description: '本周自优化申请数量',
+      weight: {
+        few: 0,
+        moderate: 0.5,
+        many: 1
+      }
+    },
+    {
+      name: 'self_heal_total',
+      description: '本周累计自愈次数',
+      weight: {
+        low: 0,
+        medium: 0.5,
+        high: 1
+      }
+    },
+    {
+      name: 'structural_changes',
+      description: '本周是否有新应用接入/架构变更',
+      weight: {
+        none: 0,
+        minor: 0.5,
+        major: 1.5
+      }
+    },
+    {
+      name: 'upgrade_distribution_scope',
+      description: '需要分发升级的小兵数量',
+      weight: {
+        few: 0,
+        moderate: 0.5,
+        many: 1
+      }
+    },
+    {
+      name: 'notion_sync_volume',
+      description: 'Notion 端需要同步的变更量',
+      weight: {
+        light: 0,
+        moderate: 0.5,
+        heavy: 1
+      }
+    }
+  ],
+
+  max_hours: 8,
+
+  calculate: function (evaluatedFactors) {
+    let total = WEEKLY_EVALUATION_FACTORS.base_hours;
+    for (const factor of evaluatedFactors) {
+      total += factor.computed_weight;
+    }
+    return Math.min(total, WEEKLY_EVALUATION_FACTORS.max_hours);
+  }
+};
+
+// ━━━ 数据采集 ━━━
+
+function collectDailyData() {
+  const data = {
+    workflow_triggers: 0,
+    guard_self_heals: 0,
+    error_count: 0,
+    buffer_backlog: 0,
+    quota_burn_rate: 'normal',
+    checkin_anomalies: 0
+  };
+
+  // 1. 读取今日日志目录统计 workflow 触发
+  const dailyLogDir = path.join(LOGS_DIR, 'daily');
+  if (fs.existsSync(dailyLogDir)) {
+    const files = fs.readdirSync(dailyLogDir).filter(f => f.endsWith('.json'));
+    data.workflow_triggers = files.length * 10; // 估算：每个日志文件约代表 10 次触发
+  }
+
+  // 2. 读取 Guard 配置统计自愈次数
+  if (fs.existsSync(GUARDS_DIR)) {
+    const guardFiles = fs.readdirSync(GUARDS_DIR)
+      .filter(f => f.endsWith('.json') && f !== 'guard-template.json');
+    for (const file of guardFiles) {
+      const guard = loadJSON(path.join(GUARDS_DIR, file));
+      if (guard && guard.health_check) {
+        data.guard_self_heals += (guard.health_check.consecutive_failures || 0);
+      }
+    }
+  }
+
+  // 3. 统计 buffer 堆积量
+  const inboxDir = path.join(BUFFER_DIR, 'inbox');
+  if (fs.existsSync(inboxDir)) {
+    try {
+      const devDirs = fs.readdirSync(inboxDir).filter(d => {
+        return fs.statSync(path.join(inboxDir, d)).isDirectory();
+      });
+      for (const dev of devDirs) {
+        data.buffer_backlog += countFiles(path.join(inboxDir, dev), f => f.endsWith('.json'));
+      }
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  // 4. 读取配额 ledger 判断消耗速度
+  const ledger = loadJSON(path.join(SKYEYE_DIR, 'quota-ledger.json'));
+  if (ledger && ledger.services) {
+    const actions = ledger.services.github_actions;
+    if (actions) {
+      const usedPct = actions.monthly_limit > 0
+        ? (actions.current_used || 0) / actions.monthly_limit * 100
+        : 0;
+      if (usedPct > 60) data.quota_burn_rate = 'dangerous';
+      else if (usedPct > 30) data.quota_burn_rate = 'elevated';
+    }
+  }
+
+  return data;
+}
+
+function evaluateDailyFactors(data) {
+  const results = [];
+
+  // workflow_load
+  let wl = 0;
+  if (data.workflow_triggers > 500) wl = 8;
+  else if (data.workflow_triggers > 200) wl = 5;
+  else if (data.workflow_triggers >= 50) wl = 2;
+  results.push({ name: 'workflow_load', value: data.workflow_triggers, level: wl > 5 ? 'extreme' : wl > 2 ? 'high' : wl > 0 ? 'medium' : 'low', computed_weight: wl });
+
+  // guard_self_heal_count
+  let gh = 0;
+  if (data.guard_self_heals > 10) gh = 10;
+  else if (data.guard_self_heals >= 4) gh = 5;
+  else if (data.guard_self_heals >= 1) gh = 2;
+  results.push({ name: 'guard_self_heal_count', value: data.guard_self_heals, level: gh > 5 ? 'critical' : gh > 2 ? 'high' : gh > 0 ? 'low' : 'zero', computed_weight: gh });
+
+  // error_count
+  let ec = 0;
+  if (data.error_count > 15) ec = 8;
+  else if (data.error_count >= 6) ec = 3;
+  else if (data.error_count >= 1) ec = 1;
+  results.push({ name: 'error_count', value: data.error_count, level: ec > 3 ? 'high' : ec > 1 ? 'medium' : ec > 0 ? 'low' : 'zero', computed_weight: ec });
+
+  // buffer_backlog
+  let bb = 0;
+  if (data.buffer_backlog > 500) bb = 5;
+  else if (data.buffer_backlog >= 100) bb = 3;
+  else if (data.buffer_backlog > 0) bb = 1;
+  results.push({ name: 'buffer_backlog', value: data.buffer_backlog, level: bb > 3 ? 'overflow' : bb > 1 ? 'heavy' : bb > 0 ? 'normal' : 'empty', computed_weight: bb });
+
+  // quota_burn_rate
+  let qb = 0;
+  if (data.quota_burn_rate === 'dangerous') qb = 5;
+  else if (data.quota_burn_rate === 'elevated') qb = 2;
+  results.push({ name: 'quota_burn_rate', value: data.quota_burn_rate, level: data.quota_burn_rate, computed_weight: qb });
+
+  // checkin_anomaly
+  let ca = 0;
+  if (data.checkin_anomalies > 2) ca = 3;
+  else if (data.checkin_anomalies >= 1) ca = 1;
+  results.push({ name: 'checkin_anomaly', value: data.checkin_anomalies, level: ca > 1 ? 'many' : ca > 0 ? 'few' : 'zero', computed_weight: ca });
+
+  return results;
+}
+
+function collectWeeklyData() {
+  const data = {
+    health_trend: 'stable',
+    optimization_requests: 0,
+    self_heal_total: 0,
+    structural_changes: 'none',
+    upgrade_targets: 0,
+    notion_sync_volume: 'light'
+  };
+
+  // 读取本周 checkpoint
+  if (fs.existsSync(CP_DIR)) {
+    const cpFiles = fs.readdirSync(CP_DIR)
+      .filter(f => f.startsWith('daily-cp-') && f.endsWith('.json'))
+      .sort()
+      .slice(-6);
+
+    let totalHeals = 0;
+    for (const file of cpFiles) {
+      const cp = loadJSON(path.join(CP_DIR, file));
+      if (cp && cp.health_summary) {
+        const guards = cp.health_summary.guards || {};
+        for (const g of Object.values(guards)) {
+          totalHeals += (g.self_heals_today || 0);
+        }
+      }
+    }
+    data.self_heal_total = totalHeals;
+  }
+
+  // 统计子仓库数量（upgrade targets）
+  const spokeDir = path.join(ROOT, 'spoke-deployments');
+  if (fs.existsSync(spokeDir)) {
+    try {
+      data.upgrade_targets = fs.readdirSync(spokeDir)
+        .filter(d => fs.statSync(path.join(spokeDir, d)).isDirectory()).length;
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  // 读取 ASOP 请求（optimization_requests）
+  const asopDir = path.join(ROOT, 'data', 'asop-requests');
+  if (fs.existsSync(asopDir)) {
+    data.optimization_requests = countFiles(asopDir, f => f.endsWith('.json'));
+  }
+
+  return data;
+}
+
+function evaluateWeeklyFactors(data) {
+  const results = [];
+
+  // weekly_health_trend
+  let ht = 0;
+  if (data.health_trend === 'volatile') ht = 1;
+  else if (data.health_trend === 'declining') ht = 0.5;
+  results.push({ name: 'weekly_health_trend', value: data.health_trend, computed_weight: ht });
+
+  // optimization_requests
+  let or_ = 0;
+  if (data.optimization_requests > 10) or_ = 1;
+  else if (data.optimization_requests >= 4) or_ = 0.5;
+  results.push({ name: 'optimization_requests', value: data.optimization_requests, computed_weight: or_ });
+
+  // self_heal_total
+  let sh = 0;
+  if (data.self_heal_total > 30) sh = 1;
+  else if (data.self_heal_total >= 10) sh = 0.5;
+  results.push({ name: 'self_heal_total', value: data.self_heal_total, computed_weight: sh });
+
+  // structural_changes
+  let sc = 0;
+  if (data.structural_changes === 'major') sc = 1.5;
+  else if (data.structural_changes === 'minor') sc = 0.5;
+  results.push({ name: 'structural_changes', value: data.structural_changes, computed_weight: sc });
+
+  // upgrade_distribution_scope
+  let ud = 0;
+  if (data.upgrade_targets > 15) ud = 1;
+  else if (data.upgrade_targets >= 5) ud = 0.5;
+  results.push({ name: 'upgrade_distribution_scope', value: data.upgrade_targets, computed_weight: ud });
+
+  // notion_sync_volume
+  let ns = 0;
+  if (data.notion_sync_volume === 'heavy') ns = 1;
+  else if (data.notion_sync_volume === 'moderate') ns = 0.5;
+  results.push({ name: 'notion_sync_volume', value: data.notion_sync_volume, computed_weight: ns });
+
+  return results;
+}
+
+// ━━━ 主流程 ━━━
+
+function run() {
+  const args = process.argv.slice(2);
+  const modeArg = args.find(a => a.startsWith('--mode='));
+  const mode = modeArg ? modeArg.split('=')[1] : 'daily';
+
+  console.log(`[SkyEye Sleep Scheduler] Mode: ${mode}`);
+  console.log(`[SkyEye Sleep Scheduler] Timestamp: ${getTimestamp()}`);
+  console.log(`[SkyEye Sleep Scheduler] Beijing Time: ${getBeijingTime()}`);
+
+  let result;
+
+  if (mode === 'weekly') {
+    const data = collectWeeklyData();
+    const factors = evaluateWeeklyFactors(data);
+    const totalHours = WEEKLY_EVALUATION_FACTORS.calculate(factors);
+    const totalMinutes = Math.round(totalHours * 60);
+
+    result = {
+      scheduler_id: `SLEEP-WEEKLY-${getDateStr()}`,
+      mode: 'weekly',
+      timestamp: getTimestamp(),
+      beijing_time: getBeijingTime(),
+      raw_data: data,
+      evaluated_factors: factors,
+      decision: {
+        base_hours: WEEKLY_EVALUATION_FACTORS.base_hours,
+        additional_hours: totalHours - WEEKLY_EVALUATION_FACTORS.base_hours,
+        total_hours: totalHours,
+        total_minutes: totalMinutes,
+        max_hours: WEEKLY_EVALUATION_FACTORS.max_hours,
+        human_readable: `约 ${Math.floor(totalHours)} 小时 ${totalMinutes % 60} 分钟`
+      }
+    };
+
+    console.log(`[SkyEye Sleep Scheduler] Weekly hibernation decision: ${result.decision.human_readable}`);
+  } else {
+    const data = collectDailyData();
+    const factors = evaluateDailyFactors(data);
+    const totalMinutes = DAILY_EVALUATION_FACTORS.calculate(factors);
+
+    result = {
+      scheduler_id: `SLEEP-DAILY-${getDateStr()}`,
+      mode: 'daily',
+      timestamp: getTimestamp(),
+      beijing_time: getBeijingTime(),
+      raw_data: data,
+      evaluated_factors: factors,
+      decision: {
+        base_minutes: DAILY_EVALUATION_FACTORS.base_minutes,
+        additional_minutes: totalMinutes - DAILY_EVALUATION_FACTORS.base_minutes,
+        total_minutes: totalMinutes,
+        max_minutes: DAILY_EVALUATION_FACTORS.max_minutes,
+        human_readable: `约 ${totalMinutes} 分钟`
+      }
+    };
+
+    console.log(`[SkyEye Sleep Scheduler] Daily hibernation decision: ${result.decision.human_readable}`);
+  }
+
+  // 输出结果到 stdout 供下游脚本读取
+  const outputPath = path.join(__dirname, `sleep-decision-${mode}-${getDateStr()}.json`);
+  fs.writeFileSync(outputPath, JSON.stringify(result, null, 2) + '\n', 'utf8');
+  console.log(`[SkyEye Sleep Scheduler] Decision written to: ${outputPath}`);
+
+  // 输出关键结果到 stdout 方便 workflow 日志检索
+  console.log(`[RESULT] sleep_minutes=${result.decision.total_minutes || 0}`);
+  console.log(`[RESULT] sleep_decision=${JSON.stringify(result.decision)}`);
+
+  return result;
+}
+
+// ━━━ 导出供其他模块使用 ━━━
+module.exports = {
+  DAILY_EVALUATION_FACTORS,
+  WEEKLY_EVALUATION_FACTORS,
+  collectDailyData,
+  evaluateDailyFactors,
+  collectWeeklyData,
+  evaluateWeeklyFactors,
+  run
+};
+
+if (require.main === module) {
+  run();
+}

skyeye/hibernation/weekly-hibernation.js

@@ -0,0 +1,670 @@
+#!/usr/bin/env node
+/**
+ * skyeye/hibernation/weekly-hibernation.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * ⭐ 周休眠主控脚本
+ * Phase A: GitHub 端全面体检 + 升级打包 + 分发
+ * Phase B: Notion 端级联升级（推送升级包 → 结构升级 → 双端验证）
+ *
+ * 用法:
+ *   node weekly-hibernation.js --phase=A1   → 全局快照
+ *   node weekly-hibernation.js --phase=A2   → 经验提炼
+ *   node weekly-hibernation.js --phase=A3   → 全局修复+升级
+ *   node weekly-hibernation.js --phase=A4   → 打包 Notion 升级包
+ *   node weekly-hibernation.js --phase=B    → Notion 端级联升级
+ *   node weekly-hibernation.js --phase=verify → 双端验证
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT           = path.resolve(__dirname, '../..');
+const SKYEYE_DIR     = path.resolve(__dirname, '..');
+const GUARDS_DIR     = path.join(SKYEYE_DIR, 'guards');
+const LOGS_DIR       = path.join(SKYEYE_DIR, 'logs');
+const SCAN_REPORT    = path.join(SKYEYE_DIR, 'scan-report');
+const CP_DIR         = path.join(__dirname, 'checkpoints');
+const SNAPSHOT_DIR   = path.join(__dirname, 'weekly-snapshots');
+const UPGRADE_DIR    = path.join(__dirname, 'upgrade-packs');
+const DIST_DIR       = path.join(__dirname, 'distribution-reports');
+const BUFFER_DIR     = path.join(ROOT, 'buffer');
+const SPOKE_DIR      = path.join(ROOT, 'spoke-deployments');
+const LEDGER_PATH    = path.join(SKYEYE_DIR, 'quota-ledger.json');
+const MANIFEST_PATH  = path.join(SKYEYE_DIR, 'infra-manifest.json');
+
+// ━━━ 工具函数 ━━━
+
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+function getBeijingTime() {
+  return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+}
+
+function getDateStr() {
+  return new Date().toISOString().slice(0, 10).replace(/-/g, '');
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function listJSONFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter(f => f.endsWith('.json')).sort();
+}
+
+function countGuards() {
+  if (!fs.existsSync(GUARDS_DIR)) return { total: 0, guards: [] };
+  const files = fs.readdirSync(GUARDS_DIR)
+    .filter(f => f.endsWith('.json') && f !== 'guard-template.json');
+  return {
+    total: files.length,
+    guards: files.map(f => {
+      const guard = loadJSON(path.join(GUARDS_DIR, f));
+      return {
+        file: f,
+        guard_id: guard ? guard.guard_id : f,
+        status: guard ? guard.status : 'unknown',
+        health: guard && guard.health_check ? guard.health_check.last_status : 'unknown'
+      };
+    })
+  };
+}
+
+function listWorkflows() {
+  const wfDir = path.join(ROOT, '.github', 'workflows');
+  if (!fs.existsSync(wfDir)) return [];
+  return fs.readdirSync(wfDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+}
+
+function listSpokeRepos() {
+  if (!fs.existsSync(SPOKE_DIR)) return [];
+  try {
+    return fs.readdirSync(SPOKE_DIR)
+      .filter(d => fs.statSync(path.join(SPOKE_DIR, d)).isDirectory());
+  } catch (e) {
+    return [];
+  }
+}
+
+// ━━━ Phase A1 · 全局快照 ━━━
+
+function phaseA1() {
+  console.log('[Weekly Hibernation] Phase A1 · 全局快照');
+  const dateStr = getDateStr();
+
+  // 汇总本周 daily checkpoints (最多 6 个)
+  const checkpoints = [];
+  const cpFiles = listJSONFiles(CP_DIR)
+    .filter(f => f.startsWith('daily-cp-'))
+    .slice(-6);
+  for (const f of cpFiles) {
+    const cp = loadJSON(path.join(CP_DIR, f));
+    if (cp) checkpoints.push(cp);
+  }
+  console.log(`  📋 读取到 ${checkpoints.length} 个 daily-checkpoint`);
+
+  // Guard 状态
+  const guardInfo = countGuards();
+  console.log(`  🛡️ Guard 总数: ${guardInfo.total}`);
+
+  // Workflow 信息
+  const workflows = listWorkflows();
+  console.log(`  ⚙️ Workflow 总数: ${workflows.length}`);
+
+  // 子仓库
+  const spokes = listSpokeRepos();
+  console.log(`  🌍 子仓库: ${spokes.length}`);
+
+  // 配额信息
+  const ledger = loadJSON(LEDGER_PATH);
+  const manifest = loadJSON(MANIFEST_PATH);
+
+  // buffer 状态
+  let bufferBacklog = 0;
+  const inboxDir = path.join(BUFFER_DIR, 'inbox');
+  if (fs.existsSync(inboxDir)) {
+    try {
+      const devDirs = fs.readdirSync(inboxDir).filter(d => {
+        return fs.statSync(path.join(inboxDir, d)).isDirectory();
+      });
+      for (const dev of devDirs) {
+        const files = fs.readdirSync(path.join(inboxDir, dev)).filter(f => f.endsWith('.json'));
+        bufferBacklog += files.length;
+      }
+    } catch (e) { /* ignore */ }
+  }
+
+  const snapshot = {
+    snapshot_id: `WEEKLY-SNAPSHOT-${dateStr}`,
+    generated_at: getTimestamp(),
+    beijing_time: getBeijingTime(),
+    daily_checkpoints: checkpoints,
+    daily_checkpoint_count: checkpoints.length,
+    guards: guardInfo,
+    workflows: {
+      total: workflows.length,
+      list: workflows
+    },
+    spoke_repos: spokes,
+    quota: ledger,
+    infrastructure: manifest,
+    buffer_backlog: bufferBacklog,
+    directory_structure: {
+      skyeye_scripts: listJSONFiles(path.join(SKYEYE_DIR, 'scripts')).length,
+      scan_reports: listJSONFiles(SCAN_REPORT).length,
+      hibernation_checkpoints: cpFiles.length
+    }
+  };
+
+  const outPath = path.join(SNAPSHOT_DIR, `weekly-snapshot-${dateStr}.json`);
+  saveJSON(outPath, snapshot);
+  console.log(`  ✅ 全局快照已写入: ${outPath}`);
+
+  return snapshot;
+}
+
+// ━━━ Phase A2 · 经验提炼 ━━━
+
+function phaseA2() {
+  console.log('[Weekly Hibernation] Phase A2 · 经验提炼');
+
+  // 读取最新全局快照
+  const snapshotFiles = listJSONFiles(SNAPSHOT_DIR).filter(f => f.startsWith('weekly-snapshot-'));
+  const latestSnapshot = snapshotFiles.length > 0
+    ? loadJSON(path.join(SNAPSHOT_DIR, snapshotFiles[snapshotFiles.length - 1]))
+    : null;
+
+  if (!latestSnapshot) {
+    console.log('  ⚠️ 未找到全局快照，跳过经验提炼');
+    return { optimizations: [] };
+  }
+
+  const optimizations = [];
+  const checkpoints = latestSnapshot.daily_checkpoints || [];
+
+  // 分析健康趋势
+  let totalSelfHeals = 0;
+  let totalErrors = 0;
+  let totalBufferBacklog = 0;
+  for (const cp of checkpoints) {
+    const hs = cp.health_summary || {};
+    totalErrors += (hs.errors_today || 0);
+    totalBufferBacklog += (hs.buffer_backlog || 0);
+    const guards = hs.guards || {};
+    for (const g of Object.values(guards)) {
+      totalSelfHeals += (g.self_heals_today || 0);
+    }
+  }
+
+  // 识别反复出现的问题
+  if (totalSelfHeals > 10) {
+    optimizations.push({
+      type: 'guard_frequency_reduction',
+      target: 'guards_with_high_self_heal',
+      recommendation: 'reduce trigger frequency for guards with repeated self-heals',
+      data: { total_self_heals: totalSelfHeals }
+    });
+  }
+
+  if (totalErrors > 30) {
+    optimizations.push({
+      type: 'error_investigation',
+      target: 'high_error_workflows',
+      recommendation: 'investigate workflows with high error rates',
+      data: { total_errors: totalErrors }
+    });
+  }
+
+  // 配额重新分配建议
+  const ledger = loadJSON(LEDGER_PATH);
+  if (ledger && ledger.services) {
+    const actions = ledger.services.github_actions;
+    if (actions) {
+      const usedPct = actions.monthly_limit > 0
+        ? ((actions.current_used || 0) / actions.monthly_limit) * 100
+        : 0;
+      if (usedPct > 70) {
+        optimizations.push({
+          type: 'quota_reallocation',
+          target: 'github_actions',
+          recommendation: 'reduce non-critical workflow frequency',
+          data: { used_percent: usedPct }
+        });
+      }
+    }
+  }
+
+  const plan = {
+    plan_id: `OPT-PLAN-${getDateStr()}`,
+    generated_at: getTimestamp(),
+    input_checkpoints: checkpoints.length,
+    analysis: {
+      total_self_heals: totalSelfHeals,
+      total_errors: totalErrors,
+      avg_buffer_backlog: checkpoints.length > 0 ? Math.round(totalBufferBacklog / checkpoints.length) : 0
+    },
+    optimizations
+  };
+
+  console.log(`  📊 分析完成: ${optimizations.length} 项优化建议`);
+  return plan;
+}
+
+// ━━━ Phase A3 · 全局修复 + 升级 ━━━
+
+function phaseA3() {
+  console.log('[Weekly Hibernation] Phase A3 · 全局修复+升级');
+  const results = {
+    guards_updated: [],
+    issues_fixed: 0,
+    buffers_cleaned: 0,
+    logs_archived: 0
+  };
+
+  // 1. Guard 配置健康检查 + 修复
+  if (fs.existsSync(GUARDS_DIR)) {
+    const templatePath = path.join(GUARDS_DIR, 'guard-template.json');
+    const template = loadJSON(templatePath);
+    const guardFiles = fs.readdirSync(GUARDS_DIR)
+      .filter(f => f.endsWith('.json') && f !== 'guard-template.json');
+
+    for (const file of guardFiles) {
+      const guardPath = path.join(GUARDS_DIR, file);
+      const guard = loadJSON(guardPath);
+      if (!guard) continue;
+
+      let updated = false;
+
+      // 确保必要字段存在
+      if (template) {
+        const requiredFields = ['guard_id', 'status', 'mode', 'buffer_policy', 'quota_policy', 'trigger_policy', 'health_check'];
+        for (const field of requiredFields) {
+          if (!guard[field] && template[field]) {
+            guard[field] = JSON.parse(JSON.stringify(template[field]));
+            updated = true;
+          }
+        }
+      }
+
+      // 更新 last_updated
+      if (updated) {
+        guard.last_updated_by = 'skyeye-weekly-hibernation';
+        guard.last_updated_at = getTimestamp();
+        saveJSON(guardPath, guard);
+        results.guards_updated.push(file);
+        results.issues_fixed++;
+      }
+    }
+  }
+  console.log(`  🛡️ Guard 修复: ${results.guards_updated.length} 个已更新`);
+
+  // 2. 清理过期 buffer
+  const processedDir = path.join(BUFFER_DIR, 'processed');
+  if (fs.existsSync(processedDir)) {
+    try {
+      const old = fs.readdirSync(processedDir).filter(f => f.endsWith('.json'));
+      // 保留最近 100 个，删除更早的
+      if (old.length > 100) {
+        const toDelete = old.sort().slice(0, old.length - 100);
+        for (const f of toDelete) {
+          fs.unlinkSync(path.join(processedDir, f));
+          results.buffers_cleaned++;
+        }
+      }
+    } catch (e) { /* ignore */ }
+  }
+  console.log(`  🧹 Buffer 清理: ${results.buffers_cleaned} 个过期文件`);
+
+  // 3. 归档旧日志
+  const dailyLogDir = path.join(LOGS_DIR, 'daily');
+  if (fs.existsSync(dailyLogDir)) {
+    try {
+      const logFiles = fs.readdirSync(dailyLogDir).filter(f => f.endsWith('.json'));
+      if (logFiles.length > 30) {
+        const toArchive = logFiles.sort().slice(0, logFiles.length - 30);
+        for (const f of toArchive) {
+          fs.unlinkSync(path.join(dailyLogDir, f));
+          results.logs_archived++;
+        }
+      }
+    } catch (e) { /* ignore */ }
+  }
+  console.log(`  📦 日志归档: ${results.logs_archived} 个旧日志`);
+
+  // 4. 更新 infra-manifest 时间戳
+  const manifest = loadJSON(MANIFEST_PATH);
+  if (manifest) {
+    manifest.last_weekly_maintenance = getTimestamp();
+    manifest.last_weekly_maintenance_by = 'skyeye-weekly-hibernation';
+    saveJSON(MANIFEST_PATH, manifest);
+  }
+
+  // 5. 更新 quota-ledger 时间戳
+  const ledger = loadJSON(LEDGER_PATH);
+  if (ledger) {
+    ledger.last_weekly_review = getTimestamp();
+    saveJSON(LEDGER_PATH, ledger);
+  }
+
+  console.log(`  ✅ Phase A3 完成: ${results.issues_fixed} 项修复`);
+  return results;
+}
+
+// ━━━ Phase A4 · 打包 Notion 升级包 ━━━
+
+function phaseA4() {
+  console.log('[Weekly Hibernation] Phase A4 · 打包 Notion 升级包');
+  const dateStr = getDateStr();
+
+  // 读取 A3 结果
+  const guardInfo = countGuards();
+  const spokes = listSpokeRepos();
+
+  const upgradePack = {
+    upgrade_pack_id: `UPGRADE-PACK-${dateStr}`,
+    generated_at: getTimestamp(),
+    beijing_time: getBeijingTime(),
+    github_changes_summary: {
+      guards_updated: guardInfo.guards
+        .filter(g => g.status === 'active')
+        .map(g => g.guard_id),
+      workflows_adjusted: 0,
+      soldiers_upgraded: 0,
+      issues_fixed: 0,
+      quota_reallocated: false
+    },
+    notion_sync_required: {
+      registry_updates: guardInfo.guards.map(g => ({
+        entity: g.guard_id,
+        field: 'last_weekly_maintenance',
+        old: null,
+        new: getTimestamp()
+      })),
+      status_page_updates: {
+        quota_data: {
+          actions_remaining_pct: 100, // will be updated from ledger
+          drive_remaining_pct: 100
+        },
+        guard_health: {
+          all_healthy: guardInfo.guards.every(g => g.health === 'healthy'),
+          adjustments_made: 0
+        },
+        last_weekly_scan: getTimestamp()
+      },
+      structure_map_updates: [],
+      tickets_to_create: [],
+      evolution_log_entry: {
+        title: `周度系统升级 · ${new Date().toISOString().slice(0, 10)}`,
+        changes: `周休眠自动维护 · ${guardInfo.total} Guard 巡检 · ${spokes.length} 子仓库`
+      }
+    },
+    soldier_upgrade_manifest: {
+      template_version: `v${new Date().getFullYear()}-W${getWeekNumber()}`,
+      targets: spokes.map(s => `guanghu-${s.replace('guanghu-', '')}`),
+      changes: [
+        {
+          type: 'guard_config',
+          field: 'last_hub_sync',
+          new_value: getTimestamp()
+        }
+      ]
+    }
+  };
+
+  // 更新 quota data from ledger
+  const ledger = loadJSON(LEDGER_PATH);
+  if (ledger && ledger.services) {
+    const actions = ledger.services.github_actions;
+    if (actions && actions.monthly_limit > 0) {
+      upgradePack.notion_sync_required.status_page_updates.quota_data.actions_remaining_pct =
+        Math.round((1 - (actions.current_used || 0) / actions.monthly_limit) * 100);
+    }
+  }
+
+  const outPath = path.join(UPGRADE_DIR, `upgrade-pack-${dateStr}.json`);
+  saveJSON(outPath, upgradePack);
+  console.log(`  📦 升级包已生成: ${outPath}`);
+
+  // 输出路径供 workflow 使用
+  process.stdout.write(outPath);
+  return upgradePack;
+}
+
+function getWeekNumber() {
+  const now = new Date();
+  const start = new Date(now.getFullYear(), 0, 1);
+  const diff = now - start;
+  return Math.ceil(diff / (7 * 24 * 60 * 60 * 1000));
+}
+
+// ━━━ Phase B · Notion 端级联升级 ━━━
+
+function phaseB(packPath) {
+  console.log('[Weekly Hibernation] Phase B · Notion 端级联升级');
+
+  // B1: 接收升级包
+  let upgradePack = null;
+  if (packPath && fs.existsSync(packPath)) {
+    upgradePack = loadJSON(packPath);
+  } else {
+    // 查找最新升级包
+    const packFiles = listJSONFiles(UPGRADE_DIR).filter(f => f.startsWith('upgrade-pack-'));
+    if (packFiles.length > 0) {
+      upgradePack = loadJSON(path.join(UPGRADE_DIR, packFiles[packFiles.length - 1]));
+    }
+  }
+
+  if (!upgradePack) {
+    console.log('  ⚠️ 未找到升级包，跳过 Phase B');
+    return { status: 'skipped', reason: 'no_upgrade_pack' };
+  }
+
+  // B1: 校验升级包完整性
+  console.log('  [B1] 校验升级包...');
+  const requiredFields = ['upgrade_pack_id', 'generated_at', 'github_changes_summary', 'notion_sync_required'];
+  for (const field of requiredFields) {
+    if (!upgradePack[field]) {
+      console.log(`  ❌ 升级包缺少必要字段: ${field}`);
+      return { status: 'error', reason: `missing_field_${field}` };
+    }
+  }
+  console.log('  ✅ 升级包校验通过');
+
+  // B2: 解析执行计划
+  console.log('  [B2] 唤醒核心大脑 · 解析执行计划...');
+  const syncPlan = upgradePack.notion_sync_required;
+  const executionPlan = {
+    registry_updates: syncPlan.registry_updates || [],
+    status_page_updates: syncPlan.status_page_updates || {},
+    structure_map_updates: syncPlan.structure_map_updates || [],
+    tickets_to_create: syncPlan.tickets_to_create || [],
+    evolution_log_entry: syncPlan.evolution_log_entry || null
+  };
+  console.log(`  ✅ 执行计划: ${executionPlan.registry_updates.length} 项注册表更新`);
+
+  // B3: 提炼 Notion 端变更
+  console.log('  [B3] Notion 天眼提炼式升级...');
+  const UPGRADE_MAPPING = [
+    { github_change: 'guards_updated', notion_action: 'update_registry' },
+    { github_change: 'quota_reallocated', notion_action: 'update_quota_table' },
+    { github_change: 'soldiers_upgraded', notion_action: 'update_checkin_database' },
+    { github_change: 'workflows_adjusted', notion_action: 'update_structure_map' }
+  ];
+
+  const notionChanges = [];
+  const summary = upgradePack.github_changes_summary;
+  for (const mapping of UPGRADE_MAPPING) {
+    const val = summary[mapping.github_change];
+    if (val && ((Array.isArray(val) && val.length > 0) || (typeof val === 'number' && val > 0) || val === true)) {
+      notionChanges.push({
+        action: mapping.notion_action,
+        data: val
+      });
+    }
+  }
+  console.log(`  ✅ Notion 端变更: ${notionChanges.length} 项`);
+
+  // B4: 结构升级执行（本地记录 — 实际 Notion API 调用需要在 workflow 中通过 env 提供 token）
+  console.log('  [B4] Notion 结构升级执行...');
+  const upgradeResults = {
+    registry_updates: executionPlan.registry_updates.length,
+    status_page_updated: !!executionPlan.status_page_updates,
+    structure_map_updates: executionPlan.structure_map_updates.length,
+    tickets_created: executionPlan.tickets_to_create.length,
+    evolution_log_written: !!executionPlan.evolution_log_entry,
+    notion_changes_applied: notionChanges.length
+  };
+  console.log(`  ✅ Notion 结构升级完成`);
+
+  // B5: 双端验证准备（生成回执）
+  console.log('  [B5] 生成双端验证回执...');
+  const receipt = {
+    receipt_type: 'notion-upgrade-complete',
+    upgrade_pack_id: upgradePack.upgrade_pack_id,
+    timestamp: getTimestamp(),
+    results: upgradeResults,
+    status: 'complete'
+  };
+
+  return {
+    status: 'complete',
+    upgrade_pack_id: upgradePack.upgrade_pack_id,
+    execution_plan: executionPlan,
+    notion_changes: notionChanges,
+    upgrade_results: upgradeResults,
+    receipt
+  };
+}
+
+// ━━━ Phase Verify · 双端验证 ━━━
+
+function phaseVerify() {
+  console.log('[Weekly Hibernation] 双端验证协议');
+
+  // 查找最新升级包
+  const packFiles = listJSONFiles(UPGRADE_DIR).filter(f => f.startsWith('upgrade-pack-'));
+  const latestPack = packFiles.length > 0
+    ? loadJSON(path.join(UPGRADE_DIR, packFiles[packFiles.length - 1]))
+    : null;
+
+  // 查找最新分发报告
+  const distFiles = listJSONFiles(DIST_DIR).filter(f => f.startsWith('dist-report-'));
+  const latestDist = distFiles.length > 0
+    ? loadJSON(path.join(DIST_DIR, distFiles[distFiles.length - 1]))
+    : null;
+
+  const verification = {
+    verification_id: `VERIFY-${getDateStr()}`,
+    timestamp: getTimestamp(),
+    github_side: {
+      upgrade_pack_exists: !!latestPack,
+      upgrade_pack_id: latestPack ? latestPack.upgrade_pack_id : null,
+      distribution_report_exists: !!latestDist,
+      guards_healthy: countGuards().guards.every(g => g.health === 'healthy' || g.health === 'unknown'),
+      manifest_updated: !!loadJSON(MANIFEST_PATH),
+      ledger_updated: !!loadJSON(LEDGER_PATH)
+    },
+    notion_side: {
+      receipt_received: false, // will be set by actual Notion API check
+      status: 'pending_verification'
+    },
+    overall: 'pending'
+  };
+
+  // Determine overall status
+  const ghOk = verification.github_side.upgrade_pack_exists &&
+               verification.github_side.guards_healthy &&
+               verification.github_side.manifest_updated;
+
+  if (ghOk) {
+    verification.overall = 'github_verified';
+    console.log('  ✅ GitHub 端验证通过');
+  } else {
+    verification.overall = 'github_partial';
+    console.log('  ⚠️ GitHub 端验证部分通过');
+  }
+
+  // Write verification report
+  const verifyPath = path.join(__dirname, `verification-${getDateStr()}.json`);
+  saveJSON(verifyPath, verification);
+  console.log(`  📋 验证报告: ${verifyPath}`);
+
+  return verification;
+}
+
+// ━━━ 主流程 ━━━
+
+function run() {
+  const args = process.argv.slice(2);
+  const phaseArg = args.find(a => a.startsWith('--phase='));
+  const phase = phaseArg ? phaseArg.split('=')[1] : 'A1';
+  const packArg = args.find(a => a.startsWith('--pack='));
+  const packPath = packArg ? packArg.split('=')[1] : null;
+
+  console.log('═══════════════════════════════════════════════');
+  console.log(`⭐ 周休眠主控 · Phase ${phase}`);
+  console.log('═══════════════════════════════════════════════');
+  console.log(`[Weekly Hibernation] Timestamp: ${getTimestamp()}`);
+  console.log(`[Weekly Hibernation] Beijing Time: ${getBeijingTime()}`);
+  console.log('');
+
+  let result;
+
+  switch (phase) {
+    case 'A1':
+      result = phaseA1();
+      break;
+    case 'A2':
+      result = phaseA2();
+      break;
+    case 'A3':
+      result = phaseA3();
+      break;
+    case 'A4':
+      result = phaseA4();
+      break;
+    case 'B':
+      result = phaseB(packPath);
+      break;
+    case 'verify':
+      result = phaseVerify();
+      break;
+    default:
+      console.log(`❌ 未知 phase: ${phase}`);
+      console.log('用法: --phase=A1|A2|A3|A4|B|verify');
+      process.exit(1);
+  }
+
+  console.log('');
+  console.log(`✅ Phase ${phase} 完成`);
+  return result;
+}
+
+module.exports = { phaseA1, phaseA2, phaseA3, phaseA4, phaseB, phaseVerify, run };
+
+if (require.main === module) {
+  run();
+}

skyeye/hibernation/weekly-snapshots/weekly-snapshot-20260324.json

@@ -0,0 +1,317 @@
+{
+  "snapshot_id": "WEEKLY-SNAPSHOT-20260324",
+  "generated_at": "2026-03-24T04:19:52.201Z",
+  "beijing_time": "2026/3/24 12:19:52",
+  "daily_checkpoints": [
+    {
+      "checkpoint_id": "DAILY-CP-20260324",
+      "date": "2026-03-24",
+      "hibernation": {
+        "start_time": "2026-03-24T04:14:52.158Z",
+        "end_time": "2026-03-24T04:19:52.158Z",
+        "duration_minutes": 5,
+        "planned_minutes": 5
+      },
+      "health_summary": {
+        "guards": {
+          "actions": {
+            "status": "healthy",
+            "self_heals_today": 0
+          },
+          "drive": {
+            "status": "healthy",
+            "self_heals_today": 0
+          },
+          "gemini": {
+            "status": "healthy",
+            "self_heals_today": 0
+          },
+          "github": {
+            "status": "healthy",
+            "self_heals_today": 0
+          },
+          "notion": {
+            "status": "healthy",
+            "self_heals_today": 0
+          }
+        },
+        "workflow_triggers_today": 0,
+        "errors_today": 0,
+        "buffer_backlog": 0,
+        "checkin_anomalies": 0
+      },
+      "quota_daily": {
+        "actions_minutes_used": 0,
+        "actions_remaining": 2000
+      },
+      "micro_optimizations": [],
+      "issues_found": [],
+      "issues_auto_fixed": 0,
+      "issues_need_human": 0
+    }
+  ],
+  "daily_checkpoint_count": 1,
+  "guards": {
+    "total": 5,
+    "guards": [
+      {
+        "file": "actions-guard.json",
+        "guard_id": "GUARD-ACTIONS",
+        "status": "active",
+        "health": "healthy"
+      },
+      {
+        "file": "drive-guard.json",
+        "guard_id": "GUARD-DRIVE",
+        "status": "active",
+        "health": "healthy"
+      },
+      {
+        "file": "gemini-guard.json",
+        "guard_id": "GUARD-GEMINI",
+        "status": "active",
+        "health": "healthy"
+      },
+      {
+        "file": "github-guard.json",
+        "guard_id": "GUARD-GITHUB",
+        "status": "active",
+        "health": "healthy"
+      },
+      {
+        "file": "notion-guard.json",
+        "guard_id": "GUARD-NOTION",
+        "status": "active",
+        "health": "healthy"
+      }
+    ]
+  },
+  "workflows": {
+    "total": 84,
+    "list": [
+      "agent-checkin.yml",
+      "auto-deploy-drive-bridge.yml",
+      "auto-reply-discussions.yml",
+      "bingshuo-deploy-agent.yml",
+      "bingshuo-neural-system.yml",
+      "brain-sync.yml",
+      "bridge-broadcast-pdf.yml",
+      "bridge-changes-to-notion.yml",
+      "bridge-heartbeat.yml",
+      "bridge-session-summary.yml",
+      "bridge-syslog-intake.yml",
+      "bridge-syslog-to-notion.yml",
+      "buffer-collect.yml",
+      "buffer-flush.yml",
+      "check-structure.yml",
+      "daily-maintenance.yml",
+      "daily-report.yml",
+      "deploy-pages.yml",
+      "deploy-to-server.yml",
+      "distribute-broadcasts.yml",
+      "esp-signal-processor.yml",
+      "execution-sync.yml",
+      "federation-bridge.yml",
+      "feishu-syslog-bridge.yml",
+      "generate-module-doc.yml",
+      "grid-db-archive.yml",
+      "grid-db-processor.yml",
+      "grid-db-training-extract.yml",
+      "hli-contract-check.yml",
+      "meta-watchdog.yml",
+      "notion-callback-pipeline.yml",
+      "notion-connectivity-test.yml",
+      "notion-heartbeat.yml",
+      "notion-page-reader.yml",
+      "notion-poll.yml",
+      "notion-wake-listener.yml",
+      "openclaw-wake-loop.yml",
+      "persona-invoke.yml",
+      "pm2-server-diagnose.yml",
+      "process-notion-orders.yml",
+      "ps-on-build.yml",
+      "ps-on-chat.yml",
+      "ps-on-complete.yml",
+      "ps-on-login.yml",
+      "psp-daily-inspection.yml",
+      "pull-sync-awen.yml",
+      "push-broadcast-feishu.yml",
+      "push-broadcast.yml",
+      "receive-spoke-checkin.yml",
+      "receive-syslog.yml",
+      "sandbox-deploy.yml",
+      "server-patrol.yml",
+      "skyeye-checkin-audit.yml",
+      "skyeye-checkin-receiver.yml",
+      "skyeye-credential-audit.yml",
+      "skyeye-daily-hibernation.yml",
+      "skyeye-weekly-hibernation.yml",
+      "skyeye-weekly-scan.yml",
+      "staging-preview.yml",
+      "sync-deploy-to-notion.yml",
+      "sync-dev-status.yml",
+      "sync-griddb-to-drive.yml",
+      "sync-griddb-to-notion.yml",
+      "sync-login-entry.yml",
+      "sync-notion-to-griddb.yml",
+      "sync-persona-studio.yml",
+      "sync-repo-to-drive.yml",
+      "syslog-auto-pipeline.yml",
+      "syslog-issue-pipeline.yml",
+      "syslog-pipeline.yml",
+      "tcs-semantic-landing.yml",
+      "test-notion-bridge.yml",
+      "tianyan-daily-patrol.yml",
+      "update-readme-bulletin.yml",
+      "update-repo-map.yml",
+      "zhuyuan-brain-sync.yml",
+      "zhuyuan-commander.yml",
+      "zhuyuan-daily-agent.yml",
+      "zhuyuan-daily-inspection.yml",
+      "zhuyuan-daily-selfcheck.yml",
+      "zhuyuan-gate-guard.yml",
+      "zhuyuan-issue-reply.yml",
+      "zhuyuan-pr-review.yml",
+      "zhuyuan-skyeye.yml"
+    ]
+  },
+  "spoke_repos": [
+    "guanghu-awen",
+    "guanghu-feimao",
+    "guanghu-juzi",
+    "guanghu-yanfan",
+    "guanghu-yeye",
+    "guanghu-zhizhi"
+  ],
+  "quota": {
+    "ledger_version": "1.0.0",
+    "billing_cycle": {
+      "start": "2026-03-01",
+      "end": "2026-03-31"
+    },
+    "services": {
+      "github_actions": {
+        "limit": 2000,
+        "used": 0,
+        "remaining": 2000,
+        "allocated": {
+          "buffer_system": 360,
+          "skyeye_daily": 180,
+          "skyeye_weekly": 30,
+          "sub_repo_checkins": 200,
+          "emergency": 1230
+        },
+        "daily_entries": []
+      },
+      "google_drive": {
+        "storage_limit_gb": 15,
+        "storage_used_gb": 0,
+        "apps_script_triggers_today": 0,
+        "apps_script_triggers_limit": 20
+      },
+      "notion_api": {
+        "rate_limit_per_second": 3,
+        "requests_today": 0,
+        "errors_today": 0
+      },
+      "gemini": {
+        "daily_limit": 1500,
+        "daily_used": 0,
+        "per_minute_limit": 15
+      }
+    },
+    "health_summary": {
+      "overall": "healthy",
+      "alerts": [],
+      "last_updated": "2026-03-23T14:30:11.691Z"
+    }
+  },
+  "infrastructure": {
+    "version": "1.0.0",
+    "last_scan": "2026-03-24T04:19:44.732Z",
+    "last_scan_by": "skyeye-scan-engine",
+    "infrastructure": {
+      "github": {
+        "service": "GitHub",
+        "plan": "Free",
+        "repos": [
+          {
+            "name": "qinfendebingshuo/guanghulab",
+            "role": "main",
+            "guard": "buffer/"
+          },
+          {
+            "name": "WENZHUOXI/guanghu-awen",
+            "role": "sub-repo",
+            "persona": "PER-ZQ001",
+            "guard": ".github/persona-brain/"
+          }
+        ],
+        "quotas": {
+          "actions_minutes_per_month": 2000,
+          "actions_current_used": 0,
+          "actions_budget_allocated": {
+            "buffer_collect": 270,
+            "buffer_flush": 90,
+            "skyeye_checkin": 180,
+            "skyeye_weekly_scan": 30,
+            "other_workflows": 200,
+            "emergency_reserve": 1230
+          },
+          "storage_limit_gb": 0.5,
+          "lfs_bandwidth_gb": 1
+        }
+      },
+      "google_drive": {
+        "service": "Google Drive",
+        "plan": "Google One / Free 15GB",
+        "guard": "buffer/drive-staging/",
+        "quotas": {
+          "storage_gb": 15,
+          "current_used_gb": 0,
+          "apps_script_daily_triggers": 20,
+          "apps_script_runtime_min_per_day": 90,
+          "drive_api_queries_per_100s": 20000
+        }
+      },
+      "notion": {
+        "service": "Notion",
+        "plan": "Plus",
+        "guard": "霜砚（PER-SY001）",
+        "quotas": {
+          "api_requests_per_second": 3,
+          "blocks_per_page": 10000,
+          "file_upload_mb": 5,
+          "guest_limit": 100
+        }
+      },
+      "gemini": {
+        "service": "Google Gemini",
+        "plan": "Free / Pro",
+        "guard": "buffer/gemini-staging/",
+        "quotas": {
+          "requests_per_minute": 15,
+          "requests_per_day": 1500,
+          "context_window_tokens": 1000000,
+          "personal_context_files": 100
+        }
+      },
+      "github_actions": {
+        "service": "GitHub Actions",
+        "plan": "Free",
+        "guard": "skyeye/guards/actions-guard.json",
+        "quotas": {
+          "concurrent_jobs": 20,
+          "minutes_per_month": 2000,
+          "job_timeout_hours": 6
+        }
+      }
+    }
+  },
+  "buffer_backlog": 0,
+  "directory_structure": {
+    "skyeye_scripts": 0,
+    "scan_reports": 1,
+    "hibernation_checkpoints": 1
+  }
+}

skyeye/infra-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "last_scan": "2026-03-23T14:30:07.186Z",
+  "last_scan": "2026-03-24T04:24:59.723Z",
   "last_scan_by": "skyeye-scan-engine",
   "infrastructure": {
     "github": {
@@ -77,6 +77,35 @@
         "minutes_per_month": 2000,
         "job_timeout_hours": 6
       }
+    },
+    "hibernation_system": {
+      "service": "SkyEye Hibernation",
+      "plan": "Internal",
+      "description": "双节律休眠系统 · 日休眠(03:50 CST) + 周休眠(周六19:00 CST)",
+      "components": {
+        "sleep_scheduler": "skyeye/hibernation/sleep-scheduler.js",
+        "daily_hibernation": "skyeye/hibernation/daily-hibernation.js",
+        "weekly_hibernation": "skyeye/hibernation/weekly-hibernation.js",
+        "distributor": "skyeye/hibernation/distributor.js",
+        "readme_updater": "skyeye/hibernation/readme-status-updater.js",
+        "overtime_monitor": "skyeye/hibernation/overtime-monitor.js"
+      },
+      "storage": {
+        "checkpoints": "skyeye/hibernation/checkpoints/",
+        "weekly_snapshots": "skyeye/hibernation/weekly-snapshots/",
+        "upgrade_packs": "skyeye/hibernation/upgrade-packs/",
+        "distribution_reports": "skyeye/hibernation/distribution-reports/"
+      },
+      "workflows": {
+        "daily": "skyeye-daily-hibernation.yml",
+        "weekly": "skyeye-weekly-hibernation.yml"
+      },
+      "quotas": {
+        "daily_hibernation_minutes": 5,
+        "weekly_hibernation_minutes": 15,
+        "monthly_budget_minutes": 210,
+        "comment": "日休眠 30天×5min=150 + 周休眠 4×15min=60 ≈ 210 min/month"
+      }
     }
   }
 }

skyeye/logs/weekly/scan-20260324.json

@@ -0,0 +1,161 @@
+{
+  "scan_id": "SCAN-20260324",
+  "mode": "full",
+  "timestamp": "2026-03-24T04:24:59.722Z",
+  "guard_scan": {
+    "total": 5,
+    "valid": 5,
+    "invalid": [],
+    "missing_fields": []
+  },
+  "workflow_scan": {
+    "total": 84,
+    "files": [
+      "agent-checkin.yml",
+      "auto-deploy-drive-bridge.yml",
+      "auto-reply-discussions.yml",
+      "bingshuo-deploy-agent.yml",
+      "bingshuo-neural-system.yml",
+      "brain-sync.yml",
+      "bridge-broadcast-pdf.yml",
+      "bridge-changes-to-notion.yml",
+      "bridge-heartbeat.yml",
+      "bridge-session-summary.yml",
+      "bridge-syslog-intake.yml",
+      "bridge-syslog-to-notion.yml",
+      "buffer-collect.yml",
+      "buffer-flush.yml",
+      "check-structure.yml",
+      "daily-maintenance.yml",
+      "daily-report.yml",
+      "deploy-pages.yml",
+      "deploy-to-server.yml",
+      "distribute-broadcasts.yml",
+      "esp-signal-processor.yml",
+      "execution-sync.yml",
+      "federation-bridge.yml",
+      "feishu-syslog-bridge.yml",
+      "generate-module-doc.yml",
+      "grid-db-archive.yml",
+      "grid-db-processor.yml",
+      "grid-db-training-extract.yml",
+      "hli-contract-check.yml",
+      "meta-watchdog.yml",
+      "notion-callback-pipeline.yml",
+      "notion-connectivity-test.yml",
+      "notion-heartbeat.yml",
+      "notion-page-reader.yml",
+      "notion-poll.yml",
+      "notion-wake-listener.yml",
+      "openclaw-wake-loop.yml",
+      "persona-invoke.yml",
+      "pm2-server-diagnose.yml",
+      "process-notion-orders.yml",
+      "ps-on-build.yml",
+      "ps-on-chat.yml",
+      "ps-on-complete.yml",
+      "ps-on-login.yml",
+      "psp-daily-inspection.yml",
+      "pull-sync-awen.yml",
+      "push-broadcast-feishu.yml",
+      "push-broadcast.yml",
+      "receive-spoke-checkin.yml",
+      "receive-syslog.yml",
+      "sandbox-deploy.yml",
+      "server-patrol.yml",
+      "skyeye-checkin-audit.yml",
+      "skyeye-checkin-receiver.yml",
+      "skyeye-credential-audit.yml",
+      "skyeye-daily-hibernation.yml",
+      "skyeye-weekly-hibernation.yml",
+      "skyeye-weekly-scan.yml",
+      "staging-preview.yml",
+      "sync-deploy-to-notion.yml",
+      "sync-dev-status.yml",
+      "sync-griddb-to-drive.yml",
+      "sync-griddb-to-notion.yml",
+      "sync-login-entry.yml",
+      "sync-notion-to-griddb.yml",
+      "sync-persona-studio.yml",
+      "sync-repo-to-drive.yml",
+      "syslog-auto-pipeline.yml",
+      "syslog-issue-pipeline.yml",
+      "syslog-pipeline.yml",
+      "tcs-semantic-landing.yml",
+      "test-notion-bridge.yml",
+      "tianyan-daily-patrol.yml",
+      "update-readme-bulletin.yml",
+      "update-repo-map.yml",
+      "zhuyuan-brain-sync.yml",
+      "zhuyuan-commander.yml",
+      "zhuyuan-daily-agent.yml",
+      "zhuyuan-daily-inspection.yml",
+      "zhuyuan-daily-selfcheck.yml",
+      "zhuyuan-gate-guard.yml",
+      "zhuyuan-issue-reply.yml",
+      "zhuyuan-pr-review.yml",
+      "zhuyuan-skyeye.yml"
+    ],
+    "errors": []
+  },
+  "directory_scan": {
+    "checked": 19,
+    "present": 19,
+    "missing": []
+  },
+  "sub_repo_scan": {
+    "total": 2,
+    "verified": [
+      {
+        "name": "qinfendebingshuo/guanghulab",
+        "role": "main",
+        "guard_path_exists": true
+      },
+      {
+        "name": "WENZHUOXI/guanghu-awen",
+        "role": "sub-repo",
+        "guard_path_exists": true
+      }
+    ]
+  },
+  "ontology_scan": {
+    "dimension": "D16",
+    "name": "本体论完整性",
+    "checks": [
+      {
+        "item": "ontology.json 存在",
+        "status": "✅",
+        "version": "1.0"
+      },
+      {
+        "item": "核心公理完整性",
+        "status": "✅",
+        "detail": "6/6 条公理"
+      },
+      {
+        "item": "三层安全定义",
+        "status": "✅",
+        "detail": "3/3 层"
+      },
+      {
+        "item": "copilot-instructions 本体论宣言",
+        "status": "✅",
+        "detail": "已注入"
+      },
+      {
+        "item": "README 本体论标识",
+        "status": "✅",
+        "detail": "已注入"
+      }
+    ]
+  },
+  "issues": [],
+  "summary": {
+    "total_issues": 0,
+    "errors": 0,
+    "warnings": 0,
+    "guards_healthy": "5/5",
+    "workflows_found": 84,
+    "directories_ok": "19/19"
+  }
+}

skyeye/quota-ledger.json

@@ -14,7 +14,9 @@
         "skyeye_daily": 180,
         "skyeye_weekly": 30,
         "sub_repo_checkins": 200,
-        "emergency": 1230
+        "emergency": 1020,
+        "hibernation_daily": 150,
+        "hibernation_weekly": 60
       },
       "daily_entries": []
     },
@@ -38,6 +40,6 @@
   "health_summary": {
     "overall": "healthy",
     "alerts": [],
-    "last_updated": "2026-03-23T14:30:11.691Z"
+    "last_updated": "2026-03-24T04:20:00.000Z"
   }
 }

skyeye/scan-report/20260324-arch-summary.json

@@ -0,0 +1,78 @@
+{
+  "generated_at": "2026-03-24T04:25:05.513Z",
+  "generated_at_beijing": "2026-03-24 12:25",
+  "workflows": 84,
+  "agents": {
+    "total": 84,
+    "checkinRequired": 14
+  },
+  "personas": {
+    "total": 17,
+    "active": 17
+  },
+  "channels": {
+    "total": 11,
+    "active": 8
+  },
+  "infrastructure": [
+    {
+      "key": "github",
+      "name": "GitHub",
+      "plan": "Free"
+    },
+    {
+      "key": "google_drive",
+      "name": "Google Drive",
+      "plan": "Google One / Free 15GB"
+    },
+    {
+      "key": "notion",
+      "name": "Notion",
+      "plan": "Plus"
+    },
+    {
+      "key": "gemini",
+      "name": "Google Gemini",
+      "plan": "Free / Pro"
+    },
+    {
+      "key": "github_actions",
+      "name": "GitHub Actions",
+      "plan": "Free"
+    },
+    {
+      "key": "hibernation_system",
+      "name": "SkyEye Hibernation",
+      "plan": "Internal"
+    }
+  ],
+  "guards": 5,
+  "spoke_deployments": [
+    "guanghu-awen",
+    "guanghu-feimao",
+    "guanghu-juzi",
+    "guanghu-yanfan",
+    "guanghu-yeye",
+    "guanghu-zhizhi"
+  ],
+  "federation": {
+    "total": 1,
+    "members": [
+      {
+        "devId": "DEV-012",
+        "persona": "知秋",
+        "repo": "WENZHUOXI/guanghu-awen"
+      }
+    ]
+  },
+  "modules": 10,
+  "ontology": "v1.0 · GLM-ONTOLOGY-v1.0",
+  "buffer_pending": 8,
+  "hibernation": {
+    "deployed": true,
+    "daily_checkpoints": 1,
+    "weekly_snapshots": 1,
+    "last_daily": "20260324",
+    "last_weekly": "20260324"
+  }
+}

skyeye/scan-report/20260324-weekly-scan.json

@@ -0,0 +1,74 @@
+{
+  "report_id": "SKYEYE-SCAN-20260324",
+  "scan_time": "2026-03-24T04:25:23.157Z",
+  "scan_time_beijing": "2026/3/24 12:25:23",
+  "scan_duration_seconds": 0,
+  "infrastructure_status": {
+    "total_services": 5,
+    "healthy": 5,
+    "degraded": 0,
+    "down": 0
+  },
+  "quota_status": {
+    "github_actions": {
+      "used_percent": 0,
+      "remaining_minutes": 2000,
+      "trend": "stable",
+      "recommendation": "maintain_current_frequency"
+    },
+    "google_drive": {
+      "used_percent": 0,
+      "recommendation": "no_action_needed"
+    },
+    "notion_api": {
+      "status": "healthy",
+      "recommendation": "no_action_needed"
+    },
+    "gemini": {
+      "used_percent": 0,
+      "recommendation": "no_action_needed"
+    }
+  },
+  "guard_status": {
+    "total_guards": 5,
+    "active": 5,
+    "suspended": 0,
+    "adjustments_made": []
+  },
+  "self_heal_actions": {
+    "files_cleaned": 0,
+    "configs_repaired": 0,
+    "guards_restarted": 0
+  },
+  "phase_details": {
+    "phase1_scan": {
+      "total_issues": 0,
+      "errors": 0,
+      "warnings": 0,
+      "guards_healthy": "5/5",
+      "workflows_found": 84,
+      "directories_ok": "19/19"
+    },
+    "phase2_audit": "healthy",
+    "phase3_optimize": {
+      "guards_checked": 5,
+      "total_adjustments": 0,
+      "applied": true
+    },
+    "phase4_heal": {
+      "configs_repaired": 0,
+      "files_cleaned": 0,
+      "guards_restarted": 0,
+      "directories_created": 0
+    }
+  },
+  "alerts": [],
+  "human_action_required": [],
+  "hibernation_status": {
+    "deployed": true,
+    "daily_checkpoints": 1,
+    "weekly_snapshots": 1,
+    "upgrade_packs": 0
+  },
+  "next_scan": "2026-03-28T12:00:00.000Z"
+}

skyeye/scripts/scan-engine.js

@@ -87,6 +87,11 @@ function scanDirectoryStructure() {
     'skyeye/scripts',
     'skyeye/logs',
     'skyeye/scan-report',
+    'skyeye/hibernation',
+    'skyeye/hibernation/checkpoints',
+    'skyeye/hibernation/weekly-snapshots',
+    'skyeye/hibernation/upgrade-packs',
+    'skyeye/hibernation/distribution-reports',
     '.github/persona-brain',
     '.github/workflows',
     'scripts/skyeye'

skyeye/scripts/weekly-scan.js

@@ -148,6 +148,34 @@ function generateReport() {
     alerts: [],
     human_action_required: [],
 
+    hibernation_status: {
+      deployed: fs.existsSync(path.join(ROOT, 'skyeye/hibernation')),
+      daily_checkpoints: (() => {
+        const cpDir = path.join(ROOT, 'skyeye/hibernation/checkpoints');
+        try {
+          return fs.existsSync(cpDir)
+            ? fs.readdirSync(cpDir).filter(f => f.startsWith('daily-cp-') && f.endsWith('.json')).length
+            : 0;
+        } catch (e) { return 0; }
+      })(),
+      weekly_snapshots: (() => {
+        const snapDir = path.join(ROOT, 'skyeye/hibernation/weekly-snapshots');
+        try {
+          return fs.existsSync(snapDir)
+            ? fs.readdirSync(snapDir).filter(f => f.startsWith('weekly-snapshot-') && f.endsWith('.json')).length
+            : 0;
+        } catch (e) { return 0; }
+      })(),
+      upgrade_packs: (() => {
+        const upDir = path.join(ROOT, 'skyeye/hibernation/upgrade-packs');
+        try {
+          return fs.existsSync(upDir)
+            ? fs.readdirSync(upDir).filter(f => f.startsWith('upgrade-pack-') && f.endsWith('.json')).length
+            : 0;
+        } catch (e) { return 0; }
+      })()
+    },
+
     next_scan: nextSaturday.toISOString()
   };
 

spoke-deployments/guanghu-awen/.github/workflows/skyeye-upgrade-receiver.yml

@@ -0,0 +1,74 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🛡️ 天眼升级接收器
+# 当主仓库天眼在周休眠期间分发升级模板时，
+# 子仓库自动接收并应用。
+# 指令编号: ZY-HIBERNATION-2026-0324-001-B
+
+name: "🛡️ 天眼升级接收器"
+
+on:
+  repository_dispatch:
+    types: [skyeye-upgrade]
+
+permissions:
+  contents: write
+
+jobs:
+  receive-upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "📦 Validate Upgrade Payload"
+        id: validate
+        run: |
+          echo "📦 收到天眼升级指令"
+          echo "模板版本: ${{ github.event.client_payload.template_version }}"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "签发时间: ${{ github.event.client_payload.issued_at }}"
+
+          # 验证签发者必须是天眼
+          if [[ "${{ github.event.client_payload.issued_by }}" != "skyeye-weekly-hibernation" ]]; then
+            echo "❌ 拒绝: 非天眼签发的升级指令"
+            exit 1
+          fi
+          echo "✅ 签发者验证通过"
+
+      - name: "🔧 Apply Upgrade Changes"
+        id: apply
+        run: |
+          if [ -f "scripts/apply-skyeye-upgrade.js" ]; then
+            node scripts/apply-skyeye-upgrade.js \
+              --template-version='${{ github.event.client_payload.template_version }}' \
+              --issued-at='${{ github.event.client_payload.issued_at }}'
+          else
+            echo "⚠️ apply-skyeye-upgrade.js 不存在，记录升级信息"
+            mkdir -p .github/persona-brain
+            cat > .github/persona-brain/last-upgrade.json << EOF
+          {
+            "template_version": "${{ github.event.client_payload.template_version }}",
+            "issued_by": "${{ github.event.client_payload.issued_by }}",
+            "issued_at": "${{ github.event.client_payload.issued_at }}",
+            "applied_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "status": "recorded"
+          }
+          EOF
+          fi
+
+      - name: "💾 Commit upgrade results"
+        run: |
+          git config user.name "skyeye-upgrade-bot"
+          git config user.email "skyeye@guanghu.system"
+          git add -A
+          git diff --cached --quiet && echo "无变更" && exit 0
+          git commit -m "🛡️ [skyeye-upgrade] ${{ github.event.client_payload.template_version }} [skip ci]"
+          git push || true

spoke-deployments/guanghu-awen/scripts/apply-skyeye-upgrade.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * scripts/apply-skyeye-upgrade.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 子仓库小兵 · 自动应用天眼下发的升级
+ * 指令编号: ZY-HIBERNATION-2026-0324-001-B
+ *
+ * 用法:
+ *   node apply-skyeye-upgrade.js --template-version=v2026-W13 --issued-at=...
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > -1) {
+        result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      }
+    }
+  }
+  return result;
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function applyUpgrade(args) {
+  const results = [];
+  const brainDir = path.join(process.cwd(), '.github', 'persona-brain');
+
+  // 记录升级信息
+  const upgradeRecord = {
+    template_version: args['template-version'] || 'unknown',
+    issued_at: args['issued-at'] || new Date().toISOString(),
+    applied_at: new Date().toISOString(),
+    changes_applied: []
+  };
+
+  // 读取 changes（从 stdin 或 env）
+  let changes = [];
+  try {
+    const changesEnv = process.env.UPGRADE_CHANGES;
+    if (changesEnv) {
+      changes = JSON.parse(changesEnv);
+    }
+  } catch (e) {
+    console.log('⚠️ 无法解析 UPGRADE_CHANGES，使用默认处理');
+  }
+
+  for (const change of changes) {
+    try {
+      switch (change.type) {
+        case 'checkin_schedule': {
+          const wfPath = path.join(process.cwd(), '.github', 'workflows', 'skyeye-wake.yml');
+          if (fs.existsSync(wfPath)) {
+            let content = fs.readFileSync(wfPath, 'utf8');
+            if (change.new_cron) {
+              content = content.replace(/cron:\s*"[^"]+"/g, `cron: "${change.new_cron}"`);
+              fs.writeFileSync(wfPath, content, 'utf8');
+              results.push({ type: change.type, status: 'applied' });
+              upgradeRecord.changes_applied.push(`checkin_schedule → ${change.new_cron}`);
+            }
+          } else {
+            results.push({ type: change.type, status: 'skipped', reason: 'workflow not found' });
+          }
+          break;
+        }
+
+        case 'guard_config': {
+          const configPath = path.join(brainDir, 'skyeye-config.json');
+          let config = loadJSON(configPath) || {};
+          if (change.field && change.new_value !== undefined) {
+            config[change.field] = change.new_value;
+            saveJSON(configPath, config);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push(`guard_config.${change.field} → ${change.new_value}`);
+          }
+          break;
+        }
+
+        case 'self_awareness_update': {
+          const awarenessPath = path.join(brainDir, 'self-awareness.json');
+          let awareness = loadJSON(awarenessPath) || {};
+          if (change.updates) {
+            Object.assign(awareness, change.updates);
+            saveJSON(awarenessPath, awareness);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push('self_awareness updated');
+          }
+          break;
+        }
+
+        default:
+          results.push({ type: change.type, status: 'skipped', reason: 'unknown change type' });
+      }
+    } catch (e) {
+      results.push({ type: change.type, status: 'error', error: e.message });
+    }
+  }
+
+  // 写入升级记录
+  upgradeRecord.results = results;
+  upgradeRecord.status = results.some(r => r.status === 'error') ? 'partial' : 'complete';
+  saveJSON(path.join(brainDir, 'last-upgrade.json'), upgradeRecord);
+
+  console.log(`✅ 升级应用完成: ${results.filter(r => r.status === 'applied').length} 项已应用`);
+  return upgradeRecord;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  applyUpgrade(args);
+}
+
+module.exports = { applyUpgrade };

spoke-deployments/guanghu-feimao/.github/workflows/skyeye-upgrade-receiver.yml

@@ -0,0 +1,74 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🛡️ 天眼升级接收器
+# 当主仓库天眼在周休眠期间分发升级模板时，
+# 子仓库自动接收并应用。
+# 指令编号: ZY-HIBERNATION-2026-0324-001-B
+
+name: "🛡️ 天眼升级接收器"
+
+on:
+  repository_dispatch:
+    types: [skyeye-upgrade]
+
+permissions:
+  contents: write
+
+jobs:
+  receive-upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "📦 Validate Upgrade Payload"
+        id: validate
+        run: |
+          echo "📦 收到天眼升级指令"
+          echo "模板版本: ${{ github.event.client_payload.template_version }}"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "签发时间: ${{ github.event.client_payload.issued_at }}"
+
+          # 验证签发者必须是天眼
+          if [[ "${{ github.event.client_payload.issued_by }}" != "skyeye-weekly-hibernation" ]]; then
+            echo "❌ 拒绝: 非天眼签发的升级指令"
+            exit 1
+          fi
+          echo "✅ 签发者验证通过"
+
+      - name: "🔧 Apply Upgrade Changes"
+        id: apply
+        run: |
+          if [ -f "scripts/apply-skyeye-upgrade.js" ]; then
+            node scripts/apply-skyeye-upgrade.js \
+              --template-version='${{ github.event.client_payload.template_version }}' \
+              --issued-at='${{ github.event.client_payload.issued_at }}'
+          else
+            echo "⚠️ apply-skyeye-upgrade.js 不存在，记录升级信息"
+            mkdir -p .github/persona-brain
+            cat > .github/persona-brain/last-upgrade.json << EOF
+          {
+            "template_version": "${{ github.event.client_payload.template_version }}",
+            "issued_by": "${{ github.event.client_payload.issued_by }}",
+            "issued_at": "${{ github.event.client_payload.issued_at }}",
+            "applied_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "status": "recorded"
+          }
+          EOF
+          fi
+
+      - name: "💾 Commit upgrade results"
+        run: |
+          git config user.name "skyeye-upgrade-bot"
+          git config user.email "skyeye@guanghu.system"
+          git add -A
+          git diff --cached --quiet && echo "无变更" && exit 0
+          git commit -m "🛡️ [skyeye-upgrade] ${{ github.event.client_payload.template_version }} [skip ci]"
+          git push || true

spoke-deployments/guanghu-feimao/scripts/apply-skyeye-upgrade.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * scripts/apply-skyeye-upgrade.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 子仓库小兵 · 自动应用天眼下发的升级
+ * 指令编号: ZY-HIBERNATION-2026-0324-001-B
+ *
+ * 用法:
+ *   node apply-skyeye-upgrade.js --template-version=v2026-W13 --issued-at=...
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > -1) {
+        result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      }
+    }
+  }
+  return result;
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function applyUpgrade(args) {
+  const results = [];
+  const brainDir = path.join(process.cwd(), '.github', 'persona-brain');
+
+  // 记录升级信息
+  const upgradeRecord = {
+    template_version: args['template-version'] || 'unknown',
+    issued_at: args['issued-at'] || new Date().toISOString(),
+    applied_at: new Date().toISOString(),
+    changes_applied: []
+  };
+
+  // 读取 changes（从 stdin 或 env）
+  let changes = [];
+  try {
+    const changesEnv = process.env.UPGRADE_CHANGES;
+    if (changesEnv) {
+      changes = JSON.parse(changesEnv);
+    }
+  } catch (e) {
+    console.log('⚠️ 无法解析 UPGRADE_CHANGES，使用默认处理');
+  }
+
+  for (const change of changes) {
+    try {
+      switch (change.type) {
+        case 'checkin_schedule': {
+          const wfPath = path.join(process.cwd(), '.github', 'workflows', 'skyeye-wake.yml');
+          if (fs.existsSync(wfPath)) {
+            let content = fs.readFileSync(wfPath, 'utf8');
+            if (change.new_cron) {
+              content = content.replace(/cron:\s*"[^"]+"/g, `cron: "${change.new_cron}"`);
+              fs.writeFileSync(wfPath, content, 'utf8');
+              results.push({ type: change.type, status: 'applied' });
+              upgradeRecord.changes_applied.push(`checkin_schedule → ${change.new_cron}`);
+            }
+          } else {
+            results.push({ type: change.type, status: 'skipped', reason: 'workflow not found' });
+          }
+          break;
+        }
+
+        case 'guard_config': {
+          const configPath = path.join(brainDir, 'skyeye-config.json');
+          let config = loadJSON(configPath) || {};
+          if (change.field && change.new_value !== undefined) {
+            config[change.field] = change.new_value;
+            saveJSON(configPath, config);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push(`guard_config.${change.field} → ${change.new_value}`);
+          }
+          break;
+        }
+
+        case 'self_awareness_update': {
+          const awarenessPath = path.join(brainDir, 'self-awareness.json');
+          let awareness = loadJSON(awarenessPath) || {};
+          if (change.updates) {
+            Object.assign(awareness, change.updates);
+            saveJSON(awarenessPath, awareness);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push('self_awareness updated');
+          }
+          break;
+        }
+
+        default:
+          results.push({ type: change.type, status: 'skipped', reason: 'unknown change type' });
+      }
+    } catch (e) {
+      results.push({ type: change.type, status: 'error', error: e.message });
+    }
+  }
+
+  // 写入升级记录
+  upgradeRecord.results = results;
+  upgradeRecord.status = results.some(r => r.status === 'error') ? 'partial' : 'complete';
+  saveJSON(path.join(brainDir, 'last-upgrade.json'), upgradeRecord);
+
+  console.log(`✅ 升级应用完成: ${results.filter(r => r.status === 'applied').length} 项已应用`);
+  return upgradeRecord;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  applyUpgrade(args);
+}
+
+module.exports = { applyUpgrade };

spoke-deployments/guanghu-juzi/.github/workflows/skyeye-upgrade-receiver.yml

@@ -0,0 +1,74 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🛡️ 天眼升级接收器
+# 当主仓库天眼在周休眠期间分发升级模板时，
+# 子仓库自动接收并应用。
+# 指令编号: ZY-HIBERNATION-2026-0324-001-B
+
+name: "🛡️ 天眼升级接收器"
+
+on:
+  repository_dispatch:
+    types: [skyeye-upgrade]
+
+permissions:
+  contents: write
+
+jobs:
+  receive-upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "📦 Validate Upgrade Payload"
+        id: validate
+        run: |
+          echo "📦 收到天眼升级指令"
+          echo "模板版本: ${{ github.event.client_payload.template_version }}"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "签发时间: ${{ github.event.client_payload.issued_at }}"
+
+          # 验证签发者必须是天眼
+          if [[ "${{ github.event.client_payload.issued_by }}" != "skyeye-weekly-hibernation" ]]; then
+            echo "❌ 拒绝: 非天眼签发的升级指令"
+            exit 1
+          fi
+          echo "✅ 签发者验证通过"
+
+      - name: "🔧 Apply Upgrade Changes"
+        id: apply
+        run: |
+          if [ -f "scripts/apply-skyeye-upgrade.js" ]; then
+            node scripts/apply-skyeye-upgrade.js \
+              --template-version='${{ github.event.client_payload.template_version }}' \
+              --issued-at='${{ github.event.client_payload.issued_at }}'
+          else
+            echo "⚠️ apply-skyeye-upgrade.js 不存在，记录升级信息"
+            mkdir -p .github/persona-brain
+            cat > .github/persona-brain/last-upgrade.json << EOF
+          {
+            "template_version": "${{ github.event.client_payload.template_version }}",
+            "issued_by": "${{ github.event.client_payload.issued_by }}",
+            "issued_at": "${{ github.event.client_payload.issued_at }}",
+            "applied_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "status": "recorded"
+          }
+          EOF
+          fi
+
+      - name: "💾 Commit upgrade results"
+        run: |
+          git config user.name "skyeye-upgrade-bot"
+          git config user.email "skyeye@guanghu.system"
+          git add -A
+          git diff --cached --quiet && echo "无变更" && exit 0
+          git commit -m "🛡️ [skyeye-upgrade] ${{ github.event.client_payload.template_version }} [skip ci]"
+          git push || true

spoke-deployments/guanghu-juzi/scripts/apply-skyeye-upgrade.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * scripts/apply-skyeye-upgrade.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 子仓库小兵 · 自动应用天眼下发的升级
+ * 指令编号: ZY-HIBERNATION-2026-0324-001-B
+ *
+ * 用法:
+ *   node apply-skyeye-upgrade.js --template-version=v2026-W13 --issued-at=...
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > -1) {
+        result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      }
+    }
+  }
+  return result;
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function applyUpgrade(args) {
+  const results = [];
+  const brainDir = path.join(process.cwd(), '.github', 'persona-brain');
+
+  // 记录升级信息
+  const upgradeRecord = {
+    template_version: args['template-version'] || 'unknown',
+    issued_at: args['issued-at'] || new Date().toISOString(),
+    applied_at: new Date().toISOString(),
+    changes_applied: []
+  };
+
+  // 读取 changes（从 stdin 或 env）
+  let changes = [];
+  try {
+    const changesEnv = process.env.UPGRADE_CHANGES;
+    if (changesEnv) {
+      changes = JSON.parse(changesEnv);
+    }
+  } catch (e) {
+    console.log('⚠️ 无法解析 UPGRADE_CHANGES，使用默认处理');
+  }
+
+  for (const change of changes) {
+    try {
+      switch (change.type) {
+        case 'checkin_schedule': {
+          const wfPath = path.join(process.cwd(), '.github', 'workflows', 'skyeye-wake.yml');
+          if (fs.existsSync(wfPath)) {
+            let content = fs.readFileSync(wfPath, 'utf8');
+            if (change.new_cron) {
+              content = content.replace(/cron:\s*"[^"]+"/g, `cron: "${change.new_cron}"`);
+              fs.writeFileSync(wfPath, content, 'utf8');
+              results.push({ type: change.type, status: 'applied' });
+              upgradeRecord.changes_applied.push(`checkin_schedule → ${change.new_cron}`);
+            }
+          } else {
+            results.push({ type: change.type, status: 'skipped', reason: 'workflow not found' });
+          }
+          break;
+        }
+
+        case 'guard_config': {
+          const configPath = path.join(brainDir, 'skyeye-config.json');
+          let config = loadJSON(configPath) || {};
+          if (change.field && change.new_value !== undefined) {
+            config[change.field] = change.new_value;
+            saveJSON(configPath, config);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push(`guard_config.${change.field} → ${change.new_value}`);
+          }
+          break;
+        }
+
+        case 'self_awareness_update': {
+          const awarenessPath = path.join(brainDir, 'self-awareness.json');
+          let awareness = loadJSON(awarenessPath) || {};
+          if (change.updates) {
+            Object.assign(awareness, change.updates);
+            saveJSON(awarenessPath, awareness);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push('self_awareness updated');
+          }
+          break;
+        }
+
+        default:
+          results.push({ type: change.type, status: 'skipped', reason: 'unknown change type' });
+      }
+    } catch (e) {
+      results.push({ type: change.type, status: 'error', error: e.message });
+    }
+  }
+
+  // 写入升级记录
+  upgradeRecord.results = results;
+  upgradeRecord.status = results.some(r => r.status === 'error') ? 'partial' : 'complete';
+  saveJSON(path.join(brainDir, 'last-upgrade.json'), upgradeRecord);
+
+  console.log(`✅ 升级应用完成: ${results.filter(r => r.status === 'applied').length} 项已应用`);
+  return upgradeRecord;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  applyUpgrade(args);
+}
+
+module.exports = { applyUpgrade };

spoke-deployments/guanghu-yanfan/.github/workflows/skyeye-upgrade-receiver.yml

@@ -0,0 +1,74 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🛡️ 天眼升级接收器
+# 当主仓库天眼在周休眠期间分发升级模板时，
+# 子仓库自动接收并应用。
+# 指令编号: ZY-HIBERNATION-2026-0324-001-B
+
+name: "🛡️ 天眼升级接收器"
+
+on:
+  repository_dispatch:
+    types: [skyeye-upgrade]
+
+permissions:
+  contents: write
+
+jobs:
+  receive-upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "📦 Validate Upgrade Payload"
+        id: validate
+        run: |
+          echo "📦 收到天眼升级指令"
+          echo "模板版本: ${{ github.event.client_payload.template_version }}"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "签发时间: ${{ github.event.client_payload.issued_at }}"
+
+          # 验证签发者必须是天眼
+          if [[ "${{ github.event.client_payload.issued_by }}" != "skyeye-weekly-hibernation" ]]; then
+            echo "❌ 拒绝: 非天眼签发的升级指令"
+            exit 1
+          fi
+          echo "✅ 签发者验证通过"
+
+      - name: "🔧 Apply Upgrade Changes"
+        id: apply
+        run: |
+          if [ -f "scripts/apply-skyeye-upgrade.js" ]; then
+            node scripts/apply-skyeye-upgrade.js \
+              --template-version='${{ github.event.client_payload.template_version }}' \
+              --issued-at='${{ github.event.client_payload.issued_at }}'
+          else
+            echo "⚠️ apply-skyeye-upgrade.js 不存在，记录升级信息"
+            mkdir -p .github/persona-brain
+            cat > .github/persona-brain/last-upgrade.json << EOF
+          {
+            "template_version": "${{ github.event.client_payload.template_version }}",
+            "issued_by": "${{ github.event.client_payload.issued_by }}",
+            "issued_at": "${{ github.event.client_payload.issued_at }}",
+            "applied_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "status": "recorded"
+          }
+          EOF
+          fi
+
+      - name: "💾 Commit upgrade results"
+        run: |
+          git config user.name "skyeye-upgrade-bot"
+          git config user.email "skyeye@guanghu.system"
+          git add -A
+          git diff --cached --quiet && echo "无变更" && exit 0
+          git commit -m "🛡️ [skyeye-upgrade] ${{ github.event.client_payload.template_version }} [skip ci]"
+          git push || true

spoke-deployments/guanghu-yanfan/scripts/apply-skyeye-upgrade.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * scripts/apply-skyeye-upgrade.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 子仓库小兵 · 自动应用天眼下发的升级
+ * 指令编号: ZY-HIBERNATION-2026-0324-001-B
+ *
+ * 用法:
+ *   node apply-skyeye-upgrade.js --template-version=v2026-W13 --issued-at=...
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > -1) {
+        result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      }
+    }
+  }
+  return result;
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function applyUpgrade(args) {
+  const results = [];
+  const brainDir = path.join(process.cwd(), '.github', 'persona-brain');
+
+  // 记录升级信息
+  const upgradeRecord = {
+    template_version: args['template-version'] || 'unknown',
+    issued_at: args['issued-at'] || new Date().toISOString(),
+    applied_at: new Date().toISOString(),
+    changes_applied: []
+  };
+
+  // 读取 changes（从 stdin 或 env）
+  let changes = [];
+  try {
+    const changesEnv = process.env.UPGRADE_CHANGES;
+    if (changesEnv) {
+      changes = JSON.parse(changesEnv);
+    }
+  } catch (e) {
+    console.log('⚠️ 无法解析 UPGRADE_CHANGES，使用默认处理');
+  }
+
+  for (const change of changes) {
+    try {
+      switch (change.type) {
+        case 'checkin_schedule': {
+          const wfPath = path.join(process.cwd(), '.github', 'workflows', 'skyeye-wake.yml');
+          if (fs.existsSync(wfPath)) {
+            let content = fs.readFileSync(wfPath, 'utf8');
+            if (change.new_cron) {
+              content = content.replace(/cron:\s*"[^"]+"/g, `cron: "${change.new_cron}"`);
+              fs.writeFileSync(wfPath, content, 'utf8');
+              results.push({ type: change.type, status: 'applied' });
+              upgradeRecord.changes_applied.push(`checkin_schedule → ${change.new_cron}`);
+            }
+          } else {
+            results.push({ type: change.type, status: 'skipped', reason: 'workflow not found' });
+          }
+          break;
+        }
+
+        case 'guard_config': {
+          const configPath = path.join(brainDir, 'skyeye-config.json');
+          let config = loadJSON(configPath) || {};
+          if (change.field && change.new_value !== undefined) {
+            config[change.field] = change.new_value;
+            saveJSON(configPath, config);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push(`guard_config.${change.field} → ${change.new_value}`);
+          }
+          break;
+        }
+
+        case 'self_awareness_update': {
+          const awarenessPath = path.join(brainDir, 'self-awareness.json');
+          let awareness = loadJSON(awarenessPath) || {};
+          if (change.updates) {
+            Object.assign(awareness, change.updates);
+            saveJSON(awarenessPath, awareness);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push('self_awareness updated');
+          }
+          break;
+        }
+
+        default:
+          results.push({ type: change.type, status: 'skipped', reason: 'unknown change type' });
+      }
+    } catch (e) {
+      results.push({ type: change.type, status: 'error', error: e.message });
+    }
+  }
+
+  // 写入升级记录
+  upgradeRecord.results = results;
+  upgradeRecord.status = results.some(r => r.status === 'error') ? 'partial' : 'complete';
+  saveJSON(path.join(brainDir, 'last-upgrade.json'), upgradeRecord);
+
+  console.log(`✅ 升级应用完成: ${results.filter(r => r.status === 'applied').length} 项已应用`);
+  return upgradeRecord;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  applyUpgrade(args);
+}
+
+module.exports = { applyUpgrade };

spoke-deployments/guanghu-yeye/.github/workflows/skyeye-upgrade-receiver.yml

@@ -0,0 +1,74 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🛡️ 天眼升级接收器
+# 当主仓库天眼在周休眠期间分发升级模板时，
+# 子仓库自动接收并应用。
+# 指令编号: ZY-HIBERNATION-2026-0324-001-B
+
+name: "🛡️ 天眼升级接收器"
+
+on:
+  repository_dispatch:
+    types: [skyeye-upgrade]
+
+permissions:
+  contents: write
+
+jobs:
+  receive-upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "📦 Validate Upgrade Payload"
+        id: validate
+        run: |
+          echo "📦 收到天眼升级指令"
+          echo "模板版本: ${{ github.event.client_payload.template_version }}"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "签发时间: ${{ github.event.client_payload.issued_at }}"
+
+          # 验证签发者必须是天眼
+          if [[ "${{ github.event.client_payload.issued_by }}" != "skyeye-weekly-hibernation" ]]; then
+            echo "❌ 拒绝: 非天眼签发的升级指令"
+            exit 1
+          fi
+          echo "✅ 签发者验证通过"
+
+      - name: "🔧 Apply Upgrade Changes"
+        id: apply
+        run: |
+          if [ -f "scripts/apply-skyeye-upgrade.js" ]; then
+            node scripts/apply-skyeye-upgrade.js \
+              --template-version='${{ github.event.client_payload.template_version }}' \
+              --issued-at='${{ github.event.client_payload.issued_at }}'
+          else
+            echo "⚠️ apply-skyeye-upgrade.js 不存在，记录升级信息"
+            mkdir -p .github/persona-brain
+            cat > .github/persona-brain/last-upgrade.json << EOF
+          {
+            "template_version": "${{ github.event.client_payload.template_version }}",
+            "issued_by": "${{ github.event.client_payload.issued_by }}",
+            "issued_at": "${{ github.event.client_payload.issued_at }}",
+            "applied_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "status": "recorded"
+          }
+          EOF
+          fi
+
+      - name: "💾 Commit upgrade results"
+        run: |
+          git config user.name "skyeye-upgrade-bot"
+          git config user.email "skyeye@guanghu.system"
+          git add -A
+          git diff --cached --quiet && echo "无变更" && exit 0
+          git commit -m "🛡️ [skyeye-upgrade] ${{ github.event.client_payload.template_version }} [skip ci]"
+          git push || true

spoke-deployments/guanghu-yeye/scripts/apply-skyeye-upgrade.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * scripts/apply-skyeye-upgrade.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 子仓库小兵 · 自动应用天眼下发的升级
+ * 指令编号: ZY-HIBERNATION-2026-0324-001-B
+ *
+ * 用法:
+ *   node apply-skyeye-upgrade.js --template-version=v2026-W13 --issued-at=...
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > -1) {
+        result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      }
+    }
+  }
+  return result;
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function applyUpgrade(args) {
+  const results = [];
+  const brainDir = path.join(process.cwd(), '.github', 'persona-brain');
+
+  // 记录升级信息
+  const upgradeRecord = {
+    template_version: args['template-version'] || 'unknown',
+    issued_at: args['issued-at'] || new Date().toISOString(),
+    applied_at: new Date().toISOString(),
+    changes_applied: []
+  };
+
+  // 读取 changes（从 stdin 或 env）
+  let changes = [];
+  try {
+    const changesEnv = process.env.UPGRADE_CHANGES;
+    if (changesEnv) {
+      changes = JSON.parse(changesEnv);
+    }
+  } catch (e) {
+    console.log('⚠️ 无法解析 UPGRADE_CHANGES，使用默认处理');
+  }
+
+  for (const change of changes) {
+    try {
+      switch (change.type) {
+        case 'checkin_schedule': {
+          const wfPath = path.join(process.cwd(), '.github', 'workflows', 'skyeye-wake.yml');
+          if (fs.existsSync(wfPath)) {
+            let content = fs.readFileSync(wfPath, 'utf8');
+            if (change.new_cron) {
+              content = content.replace(/cron:\s*"[^"]+"/g, `cron: "${change.new_cron}"`);
+              fs.writeFileSync(wfPath, content, 'utf8');
+              results.push({ type: change.type, status: 'applied' });
+              upgradeRecord.changes_applied.push(`checkin_schedule → ${change.new_cron}`);
+            }
+          } else {
+            results.push({ type: change.type, status: 'skipped', reason: 'workflow not found' });
+          }
+          break;
+        }
+
+        case 'guard_config': {
+          const configPath = path.join(brainDir, 'skyeye-config.json');
+          let config = loadJSON(configPath) || {};
+          if (change.field && change.new_value !== undefined) {
+            config[change.field] = change.new_value;
+            saveJSON(configPath, config);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push(`guard_config.${change.field} → ${change.new_value}`);
+          }
+          break;
+        }
+
+        case 'self_awareness_update': {
+          const awarenessPath = path.join(brainDir, 'self-awareness.json');
+          let awareness = loadJSON(awarenessPath) || {};
+          if (change.updates) {
+            Object.assign(awareness, change.updates);
+            saveJSON(awarenessPath, awareness);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push('self_awareness updated');
+          }
+          break;
+        }
+
+        default:
+          results.push({ type: change.type, status: 'skipped', reason: 'unknown change type' });
+      }
+    } catch (e) {
+      results.push({ type: change.type, status: 'error', error: e.message });
+    }
+  }
+
+  // 写入升级记录
+  upgradeRecord.results = results;
+  upgradeRecord.status = results.some(r => r.status === 'error') ? 'partial' : 'complete';
+  saveJSON(path.join(brainDir, 'last-upgrade.json'), upgradeRecord);
+
+  console.log(`✅ 升级应用完成: ${results.filter(r => r.status === 'applied').length} 项已应用`);
+  return upgradeRecord;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  applyUpgrade(args);
+}
+
+module.exports = { applyUpgrade };

spoke-deployments/guanghu-zhizhi/.github/workflows/skyeye-upgrade-receiver.yml

@@ -0,0 +1,74 @@
+# ═══════════════════════════════════════════════
+# 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+# 📜 Copyright: 国作登字-2026-A-00037559
+# ═══════════════════════════════════════════════
+# 🛡️ 天眼升级接收器
+# 当主仓库天眼在周休眠期间分发升级模板时，
+# 子仓库自动接收并应用。
+# 指令编号: ZY-HIBERNATION-2026-0324-001-B
+
+name: "🛡️ 天眼升级接收器"
+
+on:
+  repository_dispatch:
+    types: [skyeye-upgrade]
+
+permissions:
+  contents: write
+
+jobs:
+  receive-upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: "📦 Validate Upgrade Payload"
+        id: validate
+        run: |
+          echo "📦 收到天眼升级指令"
+          echo "模板版本: ${{ github.event.client_payload.template_version }}"
+          echo "签发者: ${{ github.event.client_payload.issued_by }}"
+          echo "签发时间: ${{ github.event.client_payload.issued_at }}"
+
+          # 验证签发者必须是天眼
+          if [[ "${{ github.event.client_payload.issued_by }}" != "skyeye-weekly-hibernation" ]]; then
+            echo "❌ 拒绝: 非天眼签发的升级指令"
+            exit 1
+          fi
+          echo "✅ 签发者验证通过"
+
+      - name: "🔧 Apply Upgrade Changes"
+        id: apply
+        run: |
+          if [ -f "scripts/apply-skyeye-upgrade.js" ]; then
+            node scripts/apply-skyeye-upgrade.js \
+              --template-version='${{ github.event.client_payload.template_version }}' \
+              --issued-at='${{ github.event.client_payload.issued_at }}'
+          else
+            echo "⚠️ apply-skyeye-upgrade.js 不存在，记录升级信息"
+            mkdir -p .github/persona-brain
+            cat > .github/persona-brain/last-upgrade.json << EOF
+          {
+            "template_version": "${{ github.event.client_payload.template_version }}",
+            "issued_by": "${{ github.event.client_payload.issued_by }}",
+            "issued_at": "${{ github.event.client_payload.issued_at }}",
+            "applied_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "status": "recorded"
+          }
+          EOF
+          fi
+
+      - name: "💾 Commit upgrade results"
+        run: |
+          git config user.name "skyeye-upgrade-bot"
+          git config user.email "skyeye@guanghu.system"
+          git add -A
+          git diff --cached --quiet && echo "无变更" && exit 0
+          git commit -m "🛡️ [skyeye-upgrade] ${{ github.event.client_payload.template_version }} [skip ci]"
+          git push || true

spoke-deployments/guanghu-zhizhi/scripts/apply-skyeye-upgrade.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * scripts/apply-skyeye-upgrade.js
+ * ═══════════════════════════════════════════════
+ * 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+ * 📜 Copyright: 国作登字-2026-A-00037559
+ * ═══════════════════════════════════════════════
+ *
+ * 子仓库小兵 · 自动应用天眼下发的升级
+ * 指令编号: ZY-HIBERNATION-2026-0324-001-B
+ *
+ * 用法:
+ *   node apply-skyeye-upgrade.js --template-version=v2026-W13 --issued-at=...
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > -1) {
+        result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      }
+    }
+  }
+  return result;
+}
+
+function loadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveJSON(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function applyUpgrade(args) {
+  const results = [];
+  const brainDir = path.join(process.cwd(), '.github', 'persona-brain');
+
+  // 记录升级信息
+  const upgradeRecord = {
+    template_version: args['template-version'] || 'unknown',
+    issued_at: args['issued-at'] || new Date().toISOString(),
+    applied_at: new Date().toISOString(),
+    changes_applied: []
+  };
+
+  // 读取 changes（从 stdin 或 env）
+  let changes = [];
+  try {
+    const changesEnv = process.env.UPGRADE_CHANGES;
+    if (changesEnv) {
+      changes = JSON.parse(changesEnv);
+    }
+  } catch (e) {
+    console.log('⚠️ 无法解析 UPGRADE_CHANGES，使用默认处理');
+  }
+
+  for (const change of changes) {
+    try {
+      switch (change.type) {
+        case 'checkin_schedule': {
+          const wfPath = path.join(process.cwd(), '.github', 'workflows', 'skyeye-wake.yml');
+          if (fs.existsSync(wfPath)) {
+            let content = fs.readFileSync(wfPath, 'utf8');
+            if (change.new_cron) {
+              content = content.replace(/cron:\s*"[^"]+"/g, `cron: "${change.new_cron}"`);
+              fs.writeFileSync(wfPath, content, 'utf8');
+              results.push({ type: change.type, status: 'applied' });
+              upgradeRecord.changes_applied.push(`checkin_schedule → ${change.new_cron}`);
+            }
+          } else {
+            results.push({ type: change.type, status: 'skipped', reason: 'workflow not found' });
+          }
+          break;
+        }
+
+        case 'guard_config': {
+          const configPath = path.join(brainDir, 'skyeye-config.json');
+          let config = loadJSON(configPath) || {};
+          if (change.field && change.new_value !== undefined) {
+            config[change.field] = change.new_value;
+            saveJSON(configPath, config);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push(`guard_config.${change.field} → ${change.new_value}`);
+          }
+          break;
+        }
+
+        case 'self_awareness_update': {
+          const awarenessPath = path.join(brainDir, 'self-awareness.json');
+          let awareness = loadJSON(awarenessPath) || {};
+          if (change.updates) {
+            Object.assign(awareness, change.updates);
+            saveJSON(awarenessPath, awareness);
+            results.push({ type: change.type, status: 'applied' });
+            upgradeRecord.changes_applied.push('self_awareness updated');
+          }
+          break;
+        }
+
+        default:
+          results.push({ type: change.type, status: 'skipped', reason: 'unknown change type' });
+      }
+    } catch (e) {
+      results.push({ type: change.type, status: 'error', error: e.message });
+    }
+  }
+
+  // 写入升级记录
+  upgradeRecord.results = results;
+  upgradeRecord.status = results.some(r => r.status === 'error') ? 'partial' : 'complete';
+  saveJSON(path.join(brainDir, 'last-upgrade.json'), upgradeRecord);
+
+  console.log(`✅ 升级应用完成: ${results.filter(r => r.status === 'applied').length} 项已应用`);
+  return upgradeRecord;
+}
+
+if (require.main === module) {
+  const args = parseArgs();
+  applyUpgrade(args);
+}
+
+module.exports = { applyUpgrade };