feat: 客户端灵动岛 + 上课时段紧急通知二次确认，并修复打包/校验脚本在 Electron 宿主下的多个缺陷

## 客户端灵动岛（动态岛）

- 新增独立透明置顶窗口：桌面中上方常驻、不占任务栏、不抢焦点（268x44 胶囊 / 404x316 详情 / 424x344 紧急）
- 三种形态与动画：隐藏 ↔ 胶囊 ↔ 详情，尺寸用 easeOutCubic 260ms 逐帧缓动、透明度单独淡入淡出
  （尺寸与淡入使用各自动画令牌，避免互相打断导致窗口卡在胶囊尺寸）
- 行为：普通通知变「新消息 · 共 N 条」胶囊，点击展开详情；上课时段自动隐藏并进入待发队列，
  下课后自动弹出；紧急通知无论是否上课立即展开（红色呼吸光晕 + 紧急角标，无需点击）
- 上课状态来自 GET /api/schedules/current（10s 心跳 + 下课时长定时器），
  新增 src/main/island.ts（控制器/IPC）、src/preload/island.ts、src/island/IslandApp.vue、
  src/renderer/island/bridge.ts、island.html 与多页 Vite 构建

## 上课时段发布紧急通知的二次确认

- 服务端：priority=URGENT 且当前处于上课时间段且未带 confirmDuringClass 时返回
  409 URGENT_DURING_CLASS（携带 current/next/week/serverTime），绕过界面调接口同样被拦截
- 新增 GET /api/schedules/current（inClass/current/next，at 参数用于诊断与测试）
- Web 管理端：全屏警告遮罩（UrgentClassWarning.vue），显示正在上的课时段与待发布标题，
  确认按钮带 3 秒倒计时（圆环进度，倒计时结束前禁用），取消即不发；并发命中 409 同样兜底弹窗

## 打包与验证脚本修复（Electron 宿主环境）

- scripts/lib/node-runtime.mjs：定位真正的 node.exe。此前经 pnpm 运行时 process.execPath 指向
  Electron，dist:server 会把 Electron 复制成安装包内的 node.exe，dist:win 会让 electron-builder 报
  Unknown argument: .../cli.js（改为显式使用真实 Node）
- scripts/lib/electron-env.mjs：启动 Electron 前清理继承的 ELECTRON_RUN_AS_NODE（否则 Electron 退化为
  纯 Node，require('electron') 直接 MODULE_NOT_FOUND），并从 path.txt 定位 electron.exe
  （process.versions.electron 存在时 import 'electron' 返回的是 API 对象而非路径）
- scripts/dist-server.mjs：新增构建产物新鲜度校验（曾出现 server 已重建但打进安装包的 shared/dist 是旧的，
  安装后服务启动即报 does not provide an export named MAX_TERM_WEEK）
- scripts/ui-smoke：新增 live-probe.mjs 真实制造/清理上课时段，Electron 驱动真实点击断言全屏警告文案、
  按钮禁用与 3 秒倒计时时长（实测 2966ms），测试后自动删除探针课表与测试通知

## 验证结果

- pnpm verify:e2e 62/62（新增上课时段拦截、二次确认后发布、普通通知不受限等 8 项）
- pnpm verify:web 8/8（新增上课时段紧急通知全屏警告 + 倒计时）
- pnpm verify:desktop 18/18（新增灵动岛窗口/上课隐藏/下课弹出/紧急立即展开/胶囊点击展开 + 截图）
- 打包后 EXE 冒烟 15/15（packaged: true，退出码 0）
- 服务端安装程序升级安装：.env 与数据库保持不变，/api/schedules/current 正常
- pnpm lint / format:check / typecheck 全部通过

packages/desktop-client/src/island/IslandApp.vue

@@ -0,0 +1,600 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue';
+import { PRIORITY_LABELS, formatDate, type IslandNotification, type IslandState } from '@classhelper/shared';
+
+/**
+ * 灵动岛渲染进程。
+ *
+ * 窗口尺寸由主进程按状态缓动（见 src/main/island.ts），这里只负责：
+ * - 按状态渲染 胶囊 / 展开卡片
+ * - 内容交叉淡入与弹簧缩放（形变动画的"内容层"）
+ * - 把用户点击（展开 / 收起 / 标为已读 / 打开应用）回传主进程
+ */
+const state = ref<IslandState>({
+  mode: 'hidden',
+  active: null,
+  queued: [],
+  inClass: false,
+  currentPeriodEnd: null,
+  reason: null,
+  updatedAt: 0,
+});
+
+const bridge = window.island;
+
+const notification = computed<IslandNotification | null>(() => state.value.active);
+const mode = computed(() => state.value.mode);
+const isUrgent = computed(() => notification.value?.priority === 'URGENT');
+const queueCount = computed(() => state.value.queued.length);
+
+const priorityLabel = computed(() =>
+  notification.value ? (PRIORITY_LABELS[notification.value.priority] ?? notification.value.priority) : '',
+);
+
+const subtitle = computed(() => {
+  if (!notification.value) return '';
+  const teacher = notification.value.teacherName ? `${notification.value.teacherName} · ` : '';
+  return `${teacher}${formatDate(notification.value.createdAt, true)}`;
+});
+
+/** 下课补发时提示"其实上课期间就到了" */
+const showAfterClassHint = computed(() => state.value.reason === 'after-class' && !state.value.inClass);
+
+function expand(): void {
+  bridge?.sendAction('expand');
+}
+
+function collapse(): void {
+  bridge?.sendAction('collapse');
+}
+
+function dismiss(): void {
+  bridge?.sendAction('dismiss');
+}
+
+function markRead(): void {
+  if (notification.value) bridge?.sendAction('mark-read', notification.value.id);
+}
+
+function openApp(): void {
+  bridge?.sendAction('open-app');
+}
+
+onMounted(async () => {
+  bridge?.onState((next) => {
+    state.value = next;
+  });
+  const initial = await bridge?.getState();
+  if (initial) state.value = initial;
+});
+</script>
+
+<template>
+  <div class="island-root">
+    <Transition name="island-pop" :duration="{ enter: 240, leave: 150 }">
+      <!-- 胶囊态：收到通知后先变成"新消息" -->
+      <button
+        v-if="mode === 'pill' && notification"
+        key="pill"
+        type="button"
+        class="island-card pill"
+        :class="{ urgent: isUrgent, 'after-class': showAfterClassHint }"
+        @click="expand"
+      >
+        <span v-if="isUrgent" class="glow" aria-hidden="true"></span>
+        <span class="pulse-dot" :class="{ urgent: isUrgent }"></span>
+        <span class="pill-icon">
+          <svg viewBox="0 0 24 24" width="15" height="15" aria-hidden="true">
+            <path
+              fill="currentColor"
+              d="M12 2a6 6 0 0 0-6 6v3.1L4.6 14a1 1 0 0 0 .9 1.5h13a1 1 0 0 0 .9-1.5L18 11.1V8a6 6 0 0 0-6-6Zm0 20a3 3 0 0 0 3-2.6H9A3 3 0 0 0 12 22Z"
+            />
+          </svg>
+        </span>
+        <span class="pill-text">
+          <span class="pill-title">
+            {{ isUrgent ? '紧急通知' : '新消息' }}
+            <template v-if="queueCount > 0">· 共 {{ queueCount + 1 }} 条</template>
+          </span>
+          <span class="pill-sub">{{ notification.teacherName || '老师' }} · 点击查看</span>
+        </span>
+        <span class="pill-chevron" aria-hidden="true">
+          <svg viewBox="0 0 24 24" width="14" height="14">
+            <path
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2.4"
+              stroke-linecap="round"
+              d="m9 6 6 6-6 6"
+            />
+          </svg>
+        </span>
+      </button>
+
+      <!-- 展开态：显示通知详情 -->
+      <section
+        v-else-if="mode === 'expanded' && notification"
+        key="expanded"
+        class="island-card expanded"
+        :class="{ urgent: isUrgent }"
+      >
+        <span v-if="isUrgent" class="glow" aria-hidden="true"></span>
+        <header class="head">
+          <span class="head-icon" :class="{ urgent: isUrgent }">
+            <svg viewBox="0 0 24 24" width="15" height="15" aria-hidden="true">
+              <path
+                fill="currentColor"
+                d="M12 2a6 6 0 0 0-6 6v3.1L4.6 14a1 1 0 0 0 .9 1.5h13a1 1 0 0 0 .9-1.5L18 11.1V8a6 6 0 0 0-6-6Zm0 20a3 3 0 0 0 3-2.6H9A3 3 0 0 0 12 22Z"
+              />
+            </svg>
+          </span>
+          <div class="head-meta">
+            <span class="badge" :class="`badge-${notification.priority.toLowerCase()}`">
+              {{ priorityLabel }}
+            </span>
+            <span v-if="isUrgent" class="live-dot">需立即查看</span>
+            <span v-else-if="showAfterClassHint" class="live-dot muted">下课后补发</span>
+            <span class="head-sub">{{ subtitle }}</span>
+          </div>
+          <button type="button" class="icon-btn" title="收起" @click="collapse">
+            <svg viewBox="0 0 24 24" width="14" height="14">
+              <path
+                fill="none"
+                stroke="currentColor"
+                stroke-width="2.4"
+                stroke-linecap="round"
+                d="m6 15 6-6 6 6"
+              />
+            </svg>
+          </button>
+        </header>
+
+        <h3 class="title">{{ notification.title }}</h3>
+        <div class="body">
+          <p class="content">{{ notification.content }}</p>
+        </div>
+
+        <footer class="foot">
+          <span v-if="queueCount > 0" class="more">还有 {{ queueCount }} 条通知</span>
+          <span v-else class="more muted">来自班级小助手</span>
+          <span class="actions">
+            <button type="button" class="ghost-btn" @click="openApp">打开应用</button>
+            <button type="button" class="ghost-btn" @click="markRead">标为已读</button>
+            <button type="button" class="solid-btn" @click="dismiss">知道了</button>
+          </span>
+        </footer>
+      </section>
+
+      <!-- 隐藏态占位（窗口不可见，仅保证 DOM 结构稳定） -->
+      <div v-else key="hidden" class="island-card hidden-placeholder"></div>
+    </Transition>
+  </div>
+</template>
+
+<style>
+html,
+body,
+#app {
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  background: transparent;
+  overflow: hidden;
+  font-family: 'PingFang SC', 'Microsoft YaHei', 'Helvetica Neue', Arial, sans-serif;
+  -webkit-user-select: none;
+  user-select: none;
+}
+
+.island-root {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  padding: 2px 4px;
+  box-sizing: border-box;
+}
+
+/* 三态卡片绝对定位，使交叉淡入淡出（并行 Transition）不会互相挤压 */
+.island-card {
+  position: absolute;
+  top: 2px;
+  right: 4px;
+  bottom: 2px;
+  left: 4px;
+  box-sizing: border-box;
+  border-radius: 24px;
+  color: #f7f8fa;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  background:
+    radial-gradient(120% 140% at 50% -20%, rgba(255, 255, 255, 0.14), rgba(255, 255, 255, 0) 55%),
+    linear-gradient(180deg, #23242a 0%, #0c0d10 100%);
+  box-shadow:
+    0 12px 28px rgba(0, 0, 0, 0.45),
+    inset 0 1px 0 rgba(255, 255, 255, 0.08);
+  transition:
+    border-color 0.28s ease,
+    box-shadow 0.28s ease,
+    background 0.28s ease;
+}
+
+/* 紧急通知：红色描边 + 独立光晕层呼吸
+   注意：无限动画必须放在内部 .glow 上，否则会让 Vue <Transition> 的
+   transitionend/animationend 判定失效，导致DOM 卡在离场状态。 */
+.island-card.urgent {
+  border-color: rgba(255, 92, 92, 0.55);
+  box-shadow:
+    0 12px 30px rgba(0, 0, 0, 0.5),
+    0 0 0 1px rgba(255, 92, 92, 0.25),
+    inset 0 1px 0 rgba(255, 255, 255, 0.1);
+}
+
+.glow {
+  position: absolute;
+  inset: -1px;
+  border-radius: inherit;
+  pointer-events: none;
+  animation: urgent-breath 2.2s ease-in-out infinite;
+}
+
+@keyframes urgent-breath {
+  0%,
+  100% {
+    box-shadow:
+      0 0 0 1px rgba(255, 92, 92, 0.22),
+      0 0 18px rgba(255, 72, 72, 0.28);
+  }
+  50% {
+    box-shadow:
+      0 0 0 1px rgba(255, 92, 92, 0.38),
+      0 0 34px rgba(255, 72, 72, 0.5);
+  }
+}
+
+/* ---------------------------------------------------------------- 胶囊态 */
+
+.island-card.pill {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 0 12px;
+  border-radius: 22px;
+  cursor: pointer;
+  font: inherit;
+  text-align: left;
+  outline: none;
+  transition:
+    transform 0.18s cubic-bezier(0.34, 1.56, 0.64, 1),
+    background 0.2s ease;
+}
+
+.island-card.pill:hover {
+  transform: translateY(-1px) scale(1.015);
+}
+
+.island-card.pill:active {
+  transform: scale(0.985);
+}
+
+.hidden-placeholder {
+  opacity: 0;
+  cursor: default;
+}
+
+.pulse-dot {
+  position: absolute;
+  top: 9px;
+  left: 14px;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: #4facfe;
+  box-shadow: 0 0 0 0 rgba(79, 172, 254, 0.6);
+  animation: dot-pulse 1.8s ease-out infinite;
+}
+
+.pulse-dot.urgent {
+  background: #ff5c5c;
+  box-shadow: 0 0 0 0 rgba(255, 92, 92, 0.7);
+}
+
+@keyframes dot-pulse {
+  0% {
+    box-shadow: 0 0 0 0 rgba(79, 172, 254, 0.55);
+  }
+  70% {
+    box-shadow: 0 0 0 9px rgba(79, 172, 254, 0);
+  }
+  100% {
+    box-shadow: 0 0 0 0 rgba(79, 172, 254, 0);
+  }
+}
+
+.pill-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  border-radius: 50%;
+  color: #9fd0ff;
+  background: rgba(79, 172, 254, 0.14);
+  flex: 0 0 auto;
+}
+
+.island-card.pill.urgent .pill-icon {
+  color: #ffb3b3;
+  background: rgba(255, 92, 92, 0.18);
+}
+
+.pill-text {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  flex: 1;
+  line-height: 1.25;
+}
+
+.pill-title {
+  font-size: 13px;
+  font-weight: 650;
+  letter-spacing: 0.2px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.pill-sub {
+  font-size: 11px;
+  color: rgba(255, 255, 255, 0.55);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.pill-chevron {
+  color: rgba(255, 255, 255, 0.4);
+  flex: 0 0 auto;
+}
+
+/* ---------------------------------------------------------------- 展开态 */
+
+.island-card.expanded {
+  display: flex;
+  flex-direction: column;
+  padding: 12px 14px 12px;
+  border-radius: 24px;
+  gap: 8px;
+}
+
+.head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.head-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  border-radius: 8px;
+  color: #9fd0ff;
+  background: rgba(79, 172, 254, 0.16);
+  flex: 0 0 auto;
+}
+
+.head-icon.urgent {
+  color: #ffc0c0;
+  background: rgba(255, 92, 92, 0.2);
+}
+
+.head-meta {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  min-width: 0;
+  flex: 1;
+}
+
+.badge {
+  font-size: 10px;
+  padding: 1px 7px;
+  border-radius: 999px;
+  font-weight: 650;
+  letter-spacing: 0.3px;
+}
+
+.badge-urgent {
+  color: #fff;
+  background: #ff4d4f;
+}
+
+.badge-high {
+  color: #3a2a00;
+  background: #ffc53d;
+}
+
+.badge-normal {
+  color: #06263f;
+  background: #6cc4ff;
+}
+
+.badge-low {
+  color: #23262b;
+  background: #c9ced6;
+}
+
+.live-dot {
+  font-size: 10px;
+  color: #ffb3b3;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.live-dot::before {
+  content: '';
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+  background: currentColor;
+  animation: dot-pulse 1.6s ease-out infinite;
+}
+
+.live-dot.muted {
+  color: rgba(255, 255, 255, 0.45);
+}
+
+.head-sub {
+  margin-left: auto;
+  font-size: 10px;
+  color: rgba(255, 255, 255, 0.42);
+  white-space: nowrap;
+}
+
+.icon-btn {
+  border: none;
+  background: rgba(255, 255, 255, 0.08);
+  color: rgba(255, 255, 255, 0.7);
+  width: 22px;
+  height: 22px;
+  border-radius: 50%;
+  cursor: pointer;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  transition:
+    background 0.18s ease,
+    transform 0.18s ease;
+  flex: 0 0 auto;
+}
+
+.icon-btn:hover {
+  background: rgba(255, 255, 255, 0.16);
+  transform: scale(1.06);
+}
+
+.title {
+  margin: 0;
+  font-size: 15px;
+  font-weight: 680;
+  line-height: 1.35;
+  letter-spacing: 0.2px;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+
+.body {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  background: rgba(255, 255, 255, 0.045);
+  border-radius: 12px;
+  padding: 9px 11px;
+}
+
+.body::-webkit-scrollbar {
+  width: 5px;
+}
+
+.body::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.18);
+  border-radius: 3px;
+}
+
+.content {
+  margin: 0;
+  font-size: 12.5px;
+  line-height: 1.72;
+  color: rgba(255, 255, 255, 0.82);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.more {
+  font-size: 11px;
+  color: #9fd0ff;
+}
+
+.more.muted {
+  color: rgba(255, 255, 255, 0.38);
+}
+
+.actions {
+  display: inline-flex;
+  gap: 6px;
+}
+
+.ghost-btn,
+.solid-btn {
+  font: inherit;
+  font-size: 11.5px;
+  border-radius: 999px;
+  padding: 4px 11px;
+  cursor: pointer;
+  border: 1px solid transparent;
+  transition:
+    background 0.18s ease,
+    border-color 0.18s ease,
+    transform 0.18s ease;
+}
+
+.ghost-btn {
+  color: rgba(255, 255, 255, 0.78);
+  background: rgba(255, 255, 255, 0.08);
+}
+
+.ghost-btn:hover {
+  background: rgba(255, 255, 255, 0.16);
+  transform: translateY(-1px);
+}
+
+.solid-btn {
+  color: #06263f;
+  background: #6cc4ff;
+  font-weight: 650;
+}
+
+.island-card.expanded.urgent .solid-btn {
+  color: #fff;
+  background: #ff4d4f;
+}
+
+.solid-btn:hover {
+  transform: translateY(-1px);
+}
+
+/* ---------------------------------------------------------------- 形变动画 */
+
+.island-pop-enter-active {
+  transition:
+    opacity 0.22s ease,
+    transform 0.34s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+
+.island-pop-leave-active {
+  transition:
+    opacity 0.16s ease,
+    transform 0.2s ease;
+}
+
+.island-pop-enter-from {
+  opacity: 0;
+  transform: scale(0.86) translateY(-8px);
+}
+
+.island-pop-leave-to {
+  opacity: 0;
+  transform: scale(0.9);
+}
+</style>

packages/desktop-client/src/island/main.ts

@@ -0,0 +1,15 @@
+import { createApp } from 'vue';
+import IslandApp from './IslandApp.vue';
+
+/**
+ * 灵动岛渲染进程入口。
+ * 刻意不引入 Element Plus 等 UI 库：这个窗口极小、常驻桌面，
+ * 保持零依赖可以让它在低配机器上也瞬间渲染。
+ */
+const app = createApp(IslandApp);
+
+app.config.errorHandler = (error) => {
+  console.error('[island] 渲染异常', error);
+};
+
+app.mount('#app');

packages/desktop-client/src/main/index.ts

@@ -1,6 +1,8 @@
 import path from 'node:path';
 import { BrowserWindow, app, shell } from 'electron';
 import { registerIpcHandlers } from './ipc.js';
+import { island, registerIslandIpc } from './island.js';
+import { logger } from './logger.js';
 import { runSmokeTest } from './smoke.js';
 
 // 主进程由 esbuild 打包为 CommonJS，因此这里可以直接使用 __dirname
@@ -75,10 +77,25 @@ if (!gotLock) {
 
   app.whenReady().then(async () => {
     registerIpcHandlers();
+    registerIslandIpc();
 
     mainWindow = createWindow();
     await loadRenderer(mainWindow);
 
+    // 灵动岛：独立的置顶透明小窗口（桌面中上方）
+    try {
+      await island.init(devServerUrl ? `${devServerUrl.replace(/\/+$/, '')}/island.html` : null);
+      // 点击灵动岛里的"打开应用"时把主窗口拉到前台
+      island.setOpenAppHandler(() => {
+        if (!mainWindow || mainWindow.isDestroyed()) return;
+        if (mainWindow.isMinimized()) mainWindow.restore();
+        mainWindow.show();
+        mainWindow.focus();
+      });
+    } catch (error) {
+      logger.error('灵动岛初始化失败（不影响主功能）', error);
+    }
+
     if (isSmokeTest) {
       try {
         await runSmokeTest(mainWindow);
@@ -90,9 +107,14 @@ if (!gotLock) {
   });
 
   app.on('window-all-closed', () => {
+    island.destroy();
     if (process.platform !== 'darwin') app.quit();
   });
 
+  app.on('before-quit', () => {
+    island.destroy();
+  });
+
   app.on('activate', async () => {
     if (BrowserWindow.getAllWindows().length === 0) {
       mainWindow = createWindow();

packages/desktop-client/src/main/island.ts

@@ -0,0 +1,506 @@
+import path from 'node:path';
+import { BrowserWindow, ipcMain, screen } from 'electron';
+import type { IslandMode, IslandNotification, IslandState } from '@classhelper/shared';
+import { logger } from './logger.js';
+
+/**
+ * 灵动岛（Dynamic Island）主进程控制器。
+ *
+ * 形态：一个独立的、无边框、透明、置顶、不占任务栏、不抢焦点的小窗口，
+ *      固定在主显示器工作区顶部居中（"桌面中上方"）。
+ *
+ * 行为（对应产品需求）：
+ * - 收到教师通知：变形为"新消息"胶囊；点击展开显示详情
+ * - 上课时间段：非紧急通知不弹出（自动隐藏），进入待发队列
+ * - 下课后：自动在桌面中上方弹出队列中的通知详情
+ * - 紧急通知：无论是否在上课，立刻展开显示详情，无需点击
+ */
+
+const SIZES: Record<IslandMode, { width: number; height: number }> = {
+  hidden: { width: 268, height: 44 },
+  pill: { width: 268, height: 44 },
+  expanded: { width: 404, height: 316 },
+};
+
+const URGENT_SIZE = { width: 424, height: 344 };
+
+/** 各状态的自动收起/隐藏时长（毫秒），0 表示不自动收起 */
+const TIMEOUTS = {
+  pill: 15_000,
+  afterClassExpanded: 14_000,
+  afterClassPill: 25_000,
+  expanded: 20_000,
+  urgent: 45_000,
+};
+
+export interface IslandPushContext {
+  inClass?: boolean;
+  currentPeriodEnd?: string | null;
+  week?: number;
+}
+
+export interface IslandClassStatePayload {
+  inClass: boolean;
+  currentPeriodEnd?: string | null;
+  week?: number;
+}
+
+type IslandActionName = 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app';
+
+interface IslandActionPayload {
+  action: IslandActionName;
+  id?: string;
+}
+
+class IslandController {
+  private win: BrowserWindow | null = null;
+  private rendererUrl: string | null = null;
+  private ready = false;
+  private pendingState: IslandState | null = null;
+  private collapseTimer: ReturnType<typeof setTimeout> | null = null;
+  /** 尺寸（形变）动画令牌：新动画会作废上一轮，避免互相打架 */
+  private boundsToken = 0;
+  /** 透明度（淡入淡出）动画令牌，与尺寸动画分开，否则淡入会立刻取消形变 */
+  private fadeToken = 0;
+
+  private state: IslandState = {
+    mode: 'hidden',
+    active: null,
+    queued: [],
+    inClass: false,
+    currentPeriodEnd: null,
+    reason: null,
+    updatedAt: Date.now(),
+  };
+
+  /** 灵动岛展开时点击"打开应用"交给外部处理 */
+  private openAppHandler: (() => void) | null = null;
+
+  setOpenAppHandler(handler: () => void): void {
+    this.openAppHandler = handler;
+  }
+
+  async init(rendererUrl: string | null): Promise<void> {
+    this.rendererUrl = rendererUrl;
+    if (this.win && !this.win.isDestroyed()) return;
+
+    const win = new BrowserWindow({
+      ...this.computeBounds(SIZES.hidden),
+      show: false,
+      frame: false,
+      transparent: true,
+      resizable: false,
+      movable: false,
+      minimizable: false,
+      maximizable: false,
+      fullscreenable: false,
+      skipTaskbar: true,
+      hasShadow: false,
+      // 不抢焦点：通知不应该打断学生正在做的事（键盘焦点仍留在原应用）
+      focusable: false,
+      alwaysOnTop: true,
+      type: 'toolbar',
+      webPreferences: {
+        preload: path.join(__dirname, '../preload/island.js'),
+        contextIsolation: true,
+        nodeIntegration: false,
+        sandbox: true,
+        backgroundThrottling: false,
+      },
+    });
+
+    win.setAlwaysOnTop(true, 'screen-saver');
+    win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    win.setIgnoreMouseEvents(false);
+    win.on('closed', () => {
+      this.win = null;
+      this.ready = false;
+    });
+
+    this.win = win;
+
+    // 开发/冒烟时把灵动岛渲染进程的日志转发到主进程，便于排查"窗口空白"之类问题
+    win.webContents.on('console-message', (...args) => {
+      const first = args[0];
+      const isEventObject = first && typeof first === 'object' && 'message' in first;
+      const level = isEventObject ? first.level : args[1];
+      const message = isEventObject ? first.message : args[2];
+      const isProblem = level === 'error' || level === 'warning' || level === 2 || level === 3;
+      if (isProblem || process.env.ELECTRON_SMOKE_TEST === '1') {
+        logger.info(`[island-renderer] ${String(message)}`);
+      }
+    });
+
+    if (rendererUrl) {
+      await win.loadURL(rendererUrl);
+    } else {
+      await win.loadFile(path.join(__dirname, '../renderer/island.html'));
+    }
+    this.ready = true;
+    if (this.pendingState) {
+      this.emit(this.pendingState);
+      this.pendingState = null;
+    }
+    // 首次进入时同步一次当前状态，保证渲染进程不会停在初始默认值
+    this.emit();
+    logger.info('灵动岛已就绪（置顶透明窗口，顶部居中）');
+  }
+
+  getWindow(): BrowserWindow | null {
+    return this.win;
+  }
+
+  getState(): IslandState {
+    return { ...this.state, queued: [...this.state.queued] };
+  }
+
+  isReady(): boolean {
+    return this.ready && Boolean(this.win) && !this.win?.isDestroyed();
+  }
+
+  /* ------------------------------------------------------------ 对外行为 */
+
+  /**
+   * 收到一条通知。
+   * - 紧急：立刻展开（无视上课时段）
+   * - 上课中：进队列并保持隐藏（下课后由 setClassState 触发弹出）
+   * - 其它：显示"新消息"胶囊，等待点击展开
+   */
+  pushNotification(notification: IslandNotification, context: IslandPushContext = {}): void {
+    const inClass = context.inClass ?? this.state.inClass;
+    this.state.inClass = inClass;
+    if (context.currentPeriodEnd !== undefined)
+      this.state.currentPeriodEnd = context.currentPeriodEnd ?? null;
+
+    if (notification.priority === 'URGENT') {
+      // 紧急插播：如果正在展示别的通知，把它放回队列
+      if (this.state.active && this.state.active.id !== notification.id) {
+        this.state.queued.push(this.state.active);
+      }
+      this.state.queued = this.state.queued.filter((item) => item.id !== notification.id);
+      this.activate(notification, 'urgent', 'expanded');
+      logger.info(`灵动岛紧急插播：${notification.title}`);
+      return;
+    }
+
+    if (inClass) {
+      // 上课时段：自动隐藏，暂存待下课后弹出
+      this.state.queued = [...this.state.queued.filter((item) => item.id !== notification.id), notification];
+      if (this.state.mode !== 'hidden') {
+        this.setState({ mode: 'hidden', reason: null });
+      }
+      this.state.updatedAt = Date.now();
+      this.emit();
+      logger.info(`灵动岛暂存通知（上课中，下课后弹出）：${notification.title}`);
+      return;
+    }
+
+    if (this.state.mode === 'expanded' && this.state.active) {
+      // 已经展开时，把当前这条挤入队列并显示新的一条
+      this.state.queued.push(this.state.active);
+    }
+    this.state.queued = [...this.state.queued.filter((item) => item.id !== notification.id), notification];
+    this.activate(notification, 'new', 'pill');
+  }
+
+  /** 上课状态变化：进入上课隐藏；下课则自动弹出队列 */
+  setClassState(payload: IslandClassStatePayload): void {
+    const wasInClass = this.state.inClass;
+    this.state.inClass = payload.inClass;
+    this.state.currentPeriodEnd = payload.currentPeriodEnd ?? null;
+
+    if (payload.inClass) {
+      if (!wasInClass) logger.info('灵动岛：进入上课时间段，自动隐藏');
+      if (this.state.mode !== 'hidden') {
+        // 上课期间自动隐藏（紧急通知也遵循，避免持续遮挡课堂投影）
+        this.setState({ mode: 'hidden', reason: null });
+      } else {
+        this.state.updatedAt = Date.now();
+        this.emit();
+      }
+      return;
+    }
+
+    if (wasInClass && !payload.inClass) {
+      logger.info('灵动岛：下课，弹出上课期间暂存的通知');
+      this.flushQueueAfterClass();
+      return;
+    }
+
+    this.state.updatedAt = Date.now();
+    this.emit();
+  }
+
+  /** 下课：弹出队列中最新的一条（展开显示详情），其余保留为"还有 N 条" */
+  flushQueueAfterClass(): void {
+    const next = this.state.queued[this.state.queued.length - 1];
+    if (!next) {
+      this.setState({ mode: 'hidden', reason: null });
+      return;
+    }
+    const urgent = this.state.queued.find((item) => item.priority === 'URGENT');
+    const target = urgent ?? next;
+    this.activate(target, 'after-class', 'expanded');
+  }
+
+  handleAction(payload: IslandActionPayload): void {
+    switch (payload.action) {
+      case 'expand':
+        if (this.state.active) {
+          this.setState({ mode: 'expanded' });
+          this.scheduleCollapse(
+            this.state.active.priority === 'URGENT' ? TIMEOUTS.urgent : TIMEOUTS.expanded,
+          );
+        }
+        break;
+      case 'collapse': {
+        const next = this.state.queued[this.state.queued.length - 1];
+        if (next) {
+          this.setState({ mode: 'pill', reason: this.state.reason });
+          this.scheduleCollapse(TIMEOUTS.pill);
+        } else {
+          this.hide();
+        }
+        break;
+      }
+      case 'dismiss':
+        this.dismissActive();
+        break;
+      case 'mark-read': {
+        const queue = this.state.queued.filter((item) => item.id !== payload.id);
+        this.state.queued = queue;
+        if (this.state.active?.id === payload.id) this.state.active = null;
+        this.state.updatedAt = Date.now();
+        if (this.state.mode === 'hidden') this.emit();
+        else this.dismissActive();
+        break;
+      }
+      case 'open-app':
+        this.openAppHandler?.();
+        break;
+      default:
+        break;
+    }
+  }
+
+  hide(): void {
+    this.clearTimers();
+    if (!this.win || this.win.isDestroyed()) return;
+    this.fadeOut();
+    this.setState({ mode: 'hidden', reason: null }, { skipWindow: true });
+  }
+
+  destroy(): void {
+    this.clearTimers();
+    if (this.win && !this.win.isDestroyed()) this.win.destroy();
+    this.win = null;
+  }
+
+  /* ------------------------------------------------------------ 内部实现 */
+
+  private dismissActive(): void {
+    this.clearTimers();
+    if (this.state.active) {
+      this.state.queued = this.state.queued.filter((item) => item.id !== this.state.active?.id);
+    }
+    this.state.active = null;
+
+    const next = this.state.queued[this.state.queued.length - 1];
+    if (next) {
+      // 还有未看的通知：退成胶囊态提示"还有 N 条"
+      this.state.active = next;
+      this.setState({ mode: 'pill', reason: 'after-class' });
+      this.scheduleCollapse(TIMEOUTS.afterClassPill);
+      return;
+    }
+    this.hide();
+  }
+
+  private activate(notification: IslandNotification, reason: IslandState['reason'], mode: IslandMode): void {
+    this.clearTimers();
+    // 正在展示的通知从队列中移出，queue 只保留"尚未看过"的
+    this.state.queued = this.state.queued.filter((item) => item.id !== notification.id);
+    this.state.active = notification;
+    this.state.updatedAt = Date.now();
+    this.setState({ mode, reason });
+    if (notification.priority === 'URGENT') {
+      this.scheduleCollapse(TIMEOUTS.urgent);
+    } else if (reason === 'after-class') {
+      this.scheduleCollapse(TIMEOUTS.afterClassExpanded);
+    } else if (mode === 'pill') {
+      this.scheduleCollapse(TIMEOUTS.pill);
+    } else {
+      this.scheduleCollapse(TIMEOUTS.expanded);
+    }
+  }
+
+  private scheduleCollapse(delayMs: number): void {
+    this.clearTimers();
+    this.collapseTimer = setTimeout(() => {
+      this.collapseTimer = null;
+      if (this.state.mode === 'expanded') {
+        const hasMore = this.state.queued.length > 1;
+        if (hasMore) {
+          this.setState({ mode: 'pill' });
+          this.scheduleCollapse(TIMEOUTS.afterClassPill);
+        } else {
+          this.hide();
+        }
+        return;
+      }
+      this.hide();
+    }, delayMs);
+  }
+
+  private clearTimers(): void {
+    if (this.collapseTimer) {
+      clearTimeout(this.collapseTimer);
+      this.collapseTimer = null;
+    }
+  }
+
+  private computeBounds(size: { width: number; height: number }): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  } {
+    const area = screen.getPrimaryDisplay().workArea;
+    return {
+      x: Math.round(area.x + (area.width - size.width) / 2),
+      y: area.y + 8,
+      width: size.width,
+      height: size.height,
+    };
+  }
+
+  /** 状态变更：先通知渲染进程，再驱动窗口尺寸/透明度动画 */
+  private setState(patch: Partial<IslandState>, options: { skipWindow?: boolean } = {}): void {
+    this.state = { ...this.state, ...patch, updatedAt: Date.now() };
+    this.emit();
+    if (!options.skipWindow) this.syncWindow();
+  }
+
+  private emit(state?: IslandState): void {
+    const payload = state ?? this.getState();
+    if (!this.win || this.win.isDestroyed()) {
+      this.pendingState = payload;
+      return;
+    }
+    if (!this.ready) {
+      this.pendingState = payload;
+      return;
+    }
+    this.win.webContents.send('island:state', payload);
+  }
+
+  private syncWindow(): void {
+    if (!this.win || this.win.isDestroyed()) return;
+
+    if (this.state.mode === 'hidden') {
+      this.fadeOut();
+      return;
+    }
+
+    const size =
+      this.state.mode === 'expanded'
+        ? this.state.active?.priority === 'URGENT'
+          ? URGENT_SIZE
+          : SIZES.expanded
+        : SIZES.pill;
+
+    if (!this.win.isVisible()) {
+      this.win.setOpacity(0);
+      this.win.showInactive();
+      this.animateBounds(size);
+      this.fadeIn();
+      return;
+    }
+    this.animateBounds(size);
+  }
+
+  private fadeIn(): void {
+    if (!this.win || this.win.isDestroyed()) return;
+    const token = ++this.fadeToken;
+    let opacity = this.win.getOpacity();
+    const step = (): void => {
+      if (!this.win || this.win.isDestroyed() || token !== this.fadeToken) return;
+      opacity = Math.min(1, opacity + 0.16);
+      this.win.setOpacity(opacity);
+      if (opacity < 1) setTimeout(step, 16);
+    };
+    step();
+  }
+
+  private fadeOut(): void {
+    if (!this.win || this.win.isDestroyed() || !this.win.isVisible()) return;
+    const token = ++this.fadeToken;
+    let opacity = this.win.getOpacity();
+    const step = (): void => {
+      if (!this.win || this.win.isDestroyed() || token !== this.fadeToken) return;
+      opacity = Math.max(0, opacity - 0.2);
+      this.win.setOpacity(opacity);
+      if (opacity > 0.02) {
+        setTimeout(step, 16);
+        return;
+      }
+      this.win.hide();
+      this.win.setOpacity(1);
+    };
+    step();
+  }
+
+  /** 尺寸/位置缓动：Windows 下没有原生窗口动画，这里按帧插值实现"形变"效果 */
+  private animateBounds(size: { width: number; height: number }): void {
+    if (!this.win || this.win.isDestroyed()) return;
+    const from = this.win.getBounds();
+    const to = this.computeBounds(size);
+    if (from.width === to.width && from.height === to.height && from.x === to.x && from.y === to.y) return;
+
+    const token = ++this.boundsToken;
+    const duration = 260;
+    const startedAt = Date.now();
+
+    const step = (): void => {
+      if (!this.win || this.win.isDestroyed() || token !== this.boundsToken) return;
+      const progress = Math.min(1, (Date.now() - startedAt) / duration);
+      const eased = 1 - Math.pow(1 - progress, 3); // easeOutCubic
+      const bounds = {
+        x: Math.round(from.x + (to.x - from.x) * eased),
+        y: Math.round(from.y + (to.y - from.y) * eased),
+        width: Math.round(from.width + (to.width - from.width) * eased),
+        height: Math.round(from.height + (to.height - from.height) * eased),
+      };
+      this.win.setBounds(bounds);
+      if (progress < 1) setTimeout(step, 12);
+    };
+    step();
+  }
+}
+
+export const island = new IslandController();
+
+/** 注册灵动岛相关 IPC（主窗口渲染进程 -> 主进程；灵动岛渲染进程 -> 主进程） */
+export function registerIslandIpc(): void {
+  ipcMain.on(
+    'island:push',
+    (_event, payload: { notification: IslandNotification; context?: IslandPushContext }) => {
+      if (!payload?.notification) return;
+      island.pushNotification(payload.notification, payload.context ?? {});
+    },
+  );
+
+  ipcMain.on('island:class-state', (_event, payload: IslandClassStatePayload) => {
+    if (!payload) return;
+    island.setClassState(payload);
+  });
+
+  ipcMain.handle('island:get-state', () => island.getState());
+
+  ipcMain.on('island:action', (_event, payload: IslandActionPayload) => {
+    if (!payload?.action) return;
+    island.handleAction(payload);
+  });
+}
+
+export { SIZES as ISLAND_SIZES, URGENT_SIZE as ISLAND_URGENT_SIZE };

packages/desktop-client/src/main/logger.ts

@@ -0,0 +1,25 @@
+/**
+ * 主进程日志（控制台输出）。
+ * 打包后的 GUI 进程没有可见的控制台，因此关键信息同时通过：
+ * - 冒烟验证的 ELECTRON_SMOKE_RESULT 结果文件
+ * - 主窗口右上角的连接状态 / 灵动岛状态
+ * 对外可见，避免"出了问题却看不到日志"。
+ */
+function timestamp(): string {
+  return new Date().toISOString();
+}
+
+export const logger = {
+  debug(message: string, ...args: unknown[]): void {
+    console.log(`[${timestamp()}] DEBUG ${message}`, ...args);
+  },
+  info(message: string, ...args: unknown[]): void {
+    console.log(`[${timestamp()}] INFO  ${message}`, ...args);
+  },
+  warn(message: string, ...args: unknown[]): void {
+    console.warn(`[${timestamp()}] WARN  ${message}`, ...args);
+  },
+  error(message: string, ...args: unknown[]): void {
+    console.error(`[${timestamp()}] ERROR ${message}`, ...args);
+  },
+};

packages/desktop-client/src/main/smoke.ts

@@ -2,7 +2,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { app } from 'electron';
 import type { BrowserWindow } from 'electron';
+import type { IslandNotification } from '@classhelper/shared';
 import { getDiagnostics } from './ipc.js';
+import { island } from './island.js';
 
 interface SmokeResult {
   name: string;
@@ -10,6 +12,177 @@ interface SmokeResult {
   detail: string;
 }
 
+type Recorder = (name: string, ok: boolean, detail?: string) => void;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** 灵动岛状态截图留档（便于人工复核外观与动画） */
+async function captureIsland(name: string): Promise<void> {
+  const dir = process.env.ISLAND_SHOTS_DIR;
+  const win = island.getWindow();
+  if (!dir || !win || win.isDestroyed() || !win.isVisible()) return;
+  try {
+    // 透明窗口直接 capturePage 会得到空白图：把它临时放到不透明背景上再截图
+    await win.webContents.executeJavaScript(
+      `document.documentElement.style.background = '#1f2733'; document.body.style.background = '#1f2733'; true`,
+    );
+    await sleep(120);
+    const image = await win.webContents.capturePage();
+    await win.webContents.executeJavaScript(
+      `document.documentElement.style.background = 'transparent'; document.body.style.background = 'transparent'; true`,
+    );
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${name}.png`), image.toPNG());
+    console.log(`[SMOKE] 灵动岛截图：${path.join(dir, `${name}.png`)}`);
+  } catch (error) {
+    console.warn('[SMOKE] 灵动岛截图失败', error);
+  }
+}
+
+/** 打印灵动岛渲染进程的真实 DOM 结构（排查空白窗口） */
+async function dumpIslandDom(_label: string): Promise<string> {
+  const win = island.getWindow();
+  if (!win || win.isDestroyed()) return 'no-window';
+  try {
+    return await win.webContents.executeJavaScript(
+      `(() => {
+         const app = document.querySelector('#app');
+         const card = document.querySelector('.island-card');
+         return JSON.stringify({
+           appChildren: app ? app.children.length : -1,
+           cardClass: card ? card.className : null,
+           text: (document.body.innerText || '').replace(/\\s+/g, ' ').slice(0, 60),
+         });
+       })()`,
+    );
+  } catch (error) {
+    return `dump-error: ${(error as Error).message}`;
+  }
+}
+
+function makeNotification(
+  id: string,
+  priority: IslandNotification['priority'],
+  title: string,
+): IslandNotification {
+  return {
+    id,
+    title,
+    content:
+      '明天下午的数学课改为在实验楼 B205 上课，请同学们提前 10 分钟到达，并携带上次发的练习册。如有疑问请联系课代表。',
+    priority,
+    createdAt: new Date().toISOString(),
+    courseName: '数学',
+    teacherName: '张老师',
+  };
+}
+
+/**
+ * 灵动岛行为验证（对应产品需求）：
+ * 1. 上课时间段收到普通通知 → 自动隐藏并暂存
+ * 2. 下课后 → 自动在桌面中上方弹出详情
+ * 3. 上课时间段收到紧急通知 → 立即展开显示详情（无需点击）
+ * 4. 非上课时段收到普通通知 → 变成"新消息"胶囊，点击后展开
+ */
+async function runIslandChecks(record: Recorder, results: SmokeResult[]): Promise<void> {
+  record('灵动岛窗口已创建（置顶/透明/不占任务栏）', island.isReady(), `ready=${island.isReady()}`);
+  if (!island.isReady()) return;
+
+  const islandWindow = island.getWindow();
+
+  // 1) 上课期间：普通通知必须保持隐藏并进入队列
+  island.setClassState({ inClass: true, currentPeriodEnd: '08:45', week: 1 });
+  island.pushNotification(makeNotification('smoke-normal-in-class', 'NORMAL', '上课期间的普通通知'), {
+    inClass: true,
+  });
+  await sleep(500);
+  const hiddenState = island.getState();
+  record(
+    '上课期间普通通知自动隐藏（暂存待下课弹出）',
+    hiddenState.mode === 'hidden' && hiddenState.queued.length === 1,
+    `mode=${hiddenState.mode} queued=${hiddenState.queued.length}`,
+  );
+  console.log(`[SMOKE] 隐藏态 DOM：${await dumpIslandDom('hidden')}`);
+
+  // 2) 下课：自动弹出暂存通知的详情
+  island.setClassState({ inClass: false, currentPeriodEnd: null, week: 1 });
+  await sleep(900);
+  const afterClassState = island.getState();
+  record(
+    '下课后自动弹出通知详情',
+    afterClassState.mode === 'expanded' && afterClassState.active?.id === 'smoke-normal-in-class',
+    `mode=${afterClassState.mode} active=${afterClassState.active?.id ?? '-'} reason=${afterClassState.reason ?? '-'}`,
+  );
+  await captureIsland('island-2-after-class');
+
+  // 3) 上课期间紧急通知：立即展开，无需点击
+  island.setClassState({ inClass: true, currentPeriodEnd: '08:45', week: 1 });
+  await sleep(300);
+  island.pushNotification(makeNotification('smoke-urgent-in-class', 'URGENT', '上课期间的紧急通知'), {
+    inClass: true,
+  });
+  await sleep(900);
+  const urgentState = island.getState();
+  record(
+    '上课期间紧急通知立即展开显示详情（无需点击）',
+    urgentState.mode === 'expanded' &&
+      urgentState.active?.id === 'smoke-urgent-in-class' &&
+      urgentState.reason === 'urgent',
+    `mode=${urgentState.mode} active=${urgentState.active?.id ?? '-'} reason=${urgentState.reason ?? '-'}`,
+  );
+  await captureIsland('island-3-urgent');
+
+  // 4) 非上课时段普通通知 → 胶囊态；点击后展开
+  island.handleAction({ action: 'dismiss' });
+  island.setClassState({ inClass: false, currentPeriodEnd: null, week: 1 });
+  await sleep(300);
+  island.pushNotification(makeNotification('smoke-normal-free', 'NORMAL', '课间收到的普通通知'), {
+    inClass: false,
+  });
+  await sleep(700);
+  const pillState = island.getState();
+  await captureIsland('island-4-pill');
+  console.log(`[SMOKE] 胶囊态 DOM：${await dumpIslandDom('pill')}`);
+
+  const clicked = await islandWindow?.webContents.executeJavaScript(
+    `(() => {
+       const pill = document.querySelector('.island-card.pill:not(.hidden-placeholder)');
+       if (!pill) return false;
+       pill.click();
+       return true;
+     })()`,
+  );
+  await sleep(800);
+  const expandedState = island.getState();
+  record(
+    '普通通知先变"新消息"胶囊，点击后展开详情',
+    pillState.mode === 'pill' && clicked === true && expandedState.mode === 'expanded',
+    `pillMode=${pillState.mode} clicked=${clicked} expandedMode=${expandedState.mode}`,
+  );
+  await captureIsland('island-5-clicked');
+
+  // 5) 灵动岛 DOM 结构自检（确保渲染进程真的画出卡片而不是空白窗口）
+  const domInfo = await islandWindow?.webContents.executeJavaScript(
+    `(() => ({
+       hasCard: Boolean(document.querySelector('.island-card')),
+       title: document.querySelector('.title')?.textContent ?? '',
+       hasActions: Boolean(document.querySelector('.solid-btn')),
+     }))()`,
+  );
+  record(
+    '灵动岛渲染进程正常绘制（卡片/标题/操作按钮）',
+    Boolean(domInfo?.hasCard && domInfo?.title && domInfo?.hasActions),
+    `title=${domInfo?.title ?? '-'} actions=${domInfo?.hasActions ?? false}`,
+  );
+
+  // 收尾：隐藏灵动岛，避免影响后续用例
+  island.handleAction({ action: 'dismiss' });
+  await sleep(300);
+  results.push({ name: '灵动岛用例收尾', ok: true, detail: '已隐藏' });
+}
+
 /**
  * Electron 冒烟验证（ELECTRON_SMOKE_TEST=1 时触发，跑完自动退出）。
  * 覆盖：preload 桥接、渲染进程挂载、登录页 DOM、IndexedDB 缓存读写、离线回退，
@@ -135,6 +308,9 @@ export async function runSmokeTest(win: BrowserWindow): Promise<void> {
   );
   record('断网时回退到本地缓存', Boolean(offline?.ok), String(offline?.detail ?? ''));
 
+  // ---------------------------------------------------------------- 灵动岛
+  await runIslandChecks(record, results);
+
   // 可选：对真实后端做联网集成自检（ELECTRON_SMOKE_ONLINE=1 时启用）
   if (process.env.ELECTRON_SMOKE_ONLINE === '1') {
     const online = await win.webContents.executeJavaScript(

packages/desktop-client/src/preload/index.ts

@@ -1,6 +1,13 @@
 import { contextBridge, ipcRenderer } from 'electron';
 import { IPC_CHANNELS } from '../main/ipc.js';
-import type { DesktopAppInfo, DesktopBridge, DesktopStoredConfig } from '../types/desktop.js';
+import type {
+  DesktopAppInfo,
+  DesktopBridge,
+  DesktopStoredConfig,
+  IslandClassStatePayload,
+  IslandPushContext,
+} from '../types/desktop.js';
+import type { IslandNotification } from '@classhelper/shared';
 
 /**
  * 预加载脚本：在开启了 contextIsolation + sandbox 的前提下，
@@ -14,6 +21,14 @@ const bridge: DesktopBridge = {
   clearConfig: (): Promise<DesktopStoredConfig> => ipcRenderer.invoke(IPC_CHANNELS.clearConfig),
   getAppInfo: (): Promise<DesktopAppInfo> => ipcRenderer.invoke(IPC_CHANNELS.appInfo),
   openExternal: (url: string): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.openExternal, url),
+
+  islandPush: (payload: { notification: IslandNotification; context?: IslandPushContext }): void => {
+    ipcRenderer.send('island:push', payload);
+  },
+  islandSetClassState: (payload: IslandClassStatePayload): void => {
+    ipcRenderer.send('island:class-state', payload);
+  },
+  islandGetState: () => ipcRenderer.invoke('island:get-state'),
 };
 
 contextBridge.exposeInMainWorld('desktop', bridge);

packages/desktop-client/src/preload/island.ts

@@ -0,0 +1,24 @@
+import { contextBridge, ipcRenderer } from 'electron';
+import type { IslandState } from '@classhelper/shared';
+
+/**
+ * 灵动岛窗口的预加载脚本。
+ * 只暴露「订阅状态」与「发送用户操作」两件事，渲染进程不接触任何 Node 能力。
+ */
+export interface IslandBridge {
+  onState(handler: (state: IslandState) => void): void;
+  sendAction(action: 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app', id?: string): void;
+  getState(): Promise<IslandState>;
+}
+
+const bridge: IslandBridge = {
+  onState: (handler) => {
+    ipcRenderer.on('island:state', (_event, state: IslandState) => handler(state));
+  },
+  sendAction: (action, id) => {
+    ipcRenderer.send('island:action', { action, id });
+  },
+  getState: () => ipcRenderer.invoke('island:get-state'),
+};
+
+contextBridge.exposeInMainWorld('island', bridge);

packages/desktop-client/src/renderer/App.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue';
+import { onMounted, onUnmounted, ref } from 'vue';
 import { useRouter } from 'vue-router';
+import { startIslandBridge, stopIslandBridge } from './island/bridge.js';
 import { useAppStore } from './stores/app.js';
 import { useAuthStore } from './stores/auth.js';
 import { useRealtimeStore } from './stores/realtime.js';
@@ -29,12 +30,19 @@ onMounted(async () => {
 
     if (auth.token) realtime.connect(appStore.serverUrl, auth.token);
 
+    // 灵动岛：开始按课表计算上课状态（上课隐藏、下课自动弹出）
+    if (auth.token) startIslandBridge();
+
     if (auth.isAuthenticated) await router.replace('/schedule');
     else await router.replace('/login');
   } finally {
     booting.value = false;
   }
 });
+
+onUnmounted(() => {
+  stopIslandBridge();
+});
 </script>
 
 <template>

packages/desktop-client/src/renderer/island/bridge.ts

@@ -0,0 +1,111 @@
+import {
+  SOCKET_EVENTS,
+  resolveClassStatus,
+  type ClassPeriod,
+  type NotificationDto,
+  type ScheduleDto,
+} from '@classhelper/shared';
+import { scheduleApi } from '../api/index.js';
+import { fetchWithCache } from '../cache/index.js';
+import { useAppStore } from '../stores/app.js';
+import { useAuthStore } from '../stores/auth.js';
+import { useRealtimeStore } from '../stores/realtime.js';
+
+/**
+ * 灵动岛桥接（渲染进程侧）。
+ *
+ * 职责：把"当前是否在上课时间段"这件事算出来并同步给主进程 ——
+ * 主进程据此决定通知是"立即弹出"还是"上课期间隐藏、下课后自动弹出"。
+ *
+ * 判定完全基于本地缓存的课表（离线也能算），并每 10 秒复算一次，
+ * 因此下课后最多 10 秒内会自动弹出暂存的通知。
+ */
+const TICK_INTERVAL_MS = 10_000;
+const REFRESH_INTERVAL_MS = 5 * 60_000;
+
+let schedules: ScheduleDto[] = [];
+let currentPeriod: ClassPeriod | null = null;
+let inClass = false;
+let tickTimer: ReturnType<typeof setInterval> | null = null;
+let refreshTimer: ReturnType<typeof setInterval> | null = null;
+
+/** 供通知投递时读取：当前是否上课 + 本节课结束时间 */
+export function getIslandClassContext(): { inClass: boolean; currentPeriodEnd: string | null } {
+  return { inClass, currentPeriodEnd: currentPeriod?.endTime ?? null };
+}
+
+export function getIslandSchedules(): ScheduleDto[] {
+  return schedules;
+}
+
+/** 主动刷新课表（课表变更事件触发） */
+export async function refreshIslandSchedules(): Promise<void> {
+  const appStore = useAppStore();
+  const auth = useAuthStore();
+  if (!auth.token) return;
+
+  const week = appStore.currentWeek;
+  const result = await fetchWithCache<ScheduleDto[]>(
+    'schedules',
+    `week:${week}`,
+    () => scheduleApi.list({ classId: auth.classId ?? undefined, week }),
+    [],
+  );
+  schedules = result.data;
+  recomputeClassState(true);
+}
+
+function recomputeClassState(force = false): void {
+  const appStore = useAppStore();
+  const status = resolveClassStatus(schedules, new Date(), appStore.currentWeek);
+  const nextInClass = status.inClass;
+  currentPeriod = status.current;
+
+  if (!force && nextInClass === inClass) return;
+  inClass = nextInClass;
+
+  window.desktop?.islandSetClassState({
+    inClass,
+    currentPeriodEnd: currentPeriod?.endTime ?? null,
+    week: appStore.currentWeek,
+  });
+}
+
+/** 把校园通知投递到灵动岛（由实时通道收到 notification:new 时调用） */
+export function pushNotificationToIsland(notification: NotificationDto): void {
+  window.desktop?.islandPush({
+    notification: {
+      id: notification.id,
+      title: notification.title,
+      content: notification.content,
+      priority: notification.priority,
+      createdAt: notification.createdAt,
+      courseName: currentPeriod?.courseName ?? null,
+      teacherName: notification.creator?.name ?? null,
+    },
+    context: getIslandClassContext(),
+  });
+}
+
+export function startIslandBridge(): void {
+  if (tickTimer) return;
+
+  void refreshIslandSchedules().catch(() => undefined);
+
+  // 课表变更（教师改课）立即复算，避免"下课后不弹出"或"上课没隐藏"
+  useRealtimeStore().on(SOCKET_EVENTS.scheduleUpdated, () => {
+    void refreshIslandSchedules().catch(() => undefined);
+  });
+
+  tickTimer = setInterval(() => recomputeClassState(), TICK_INTERVAL_MS);
+  refreshTimer = setInterval(() => {
+    void refreshIslandSchedules().catch(() => undefined);
+  }, REFRESH_INTERVAL_MS);
+}
+
+export function stopIslandBridge(): void {
+  if (tickTimer) clearInterval(tickTimer);
+  if (refreshTimer) clearInterval(refreshTimer);
+  tickTimer = null;
+  refreshTimer = null;
+}

packages/desktop-client/src/renderer/stores/realtime.ts

@@ -11,6 +11,7 @@ import {
   type ServerToClientEvents,
 } from '@classhelper/shared';
 import { socketUrlOf } from '../config.js';
+import { pushNotificationToIsland } from '../island/bridge.js';
 
 type RealtimeEventName = keyof ServerToClientEvents;
 type EventHandler = (payload: unknown) => void;
@@ -70,6 +71,8 @@ export const useRealtimeStore = defineStore('realtime', () => {
         duration: 5000,
         showClose: true,
       });
+      // 投递到桌面灵动岛：紧急通知立即展开；上课期间的非紧急通知会暂存，下课后自动弹出
+      pushNotificationToIsland(payload);
       dispatch(SOCKET_EVENTS.notificationNew, payload);
     });
 

packages/desktop-client/src/types/desktop.d.ts

@@ -1,7 +1,8 @@
 /**
  * 主进程与渲染进程之间的桥接契约（preload 通过 contextBridge 暴露）。
- * 渲染进程只依赖这个最小 API，不接触 Node.js。
+ * 渲染进程只依赖这些最小 API，不接触 Node.js。
  */
+import type { IslandNotification, IslandState } from '@classhelper/shared';
 
 export interface DesktopStoredConfig {
   /** 后端服务地址，例如 http://127.0.0.1:4000 */
@@ -23,6 +24,21 @@ export interface DesktopAppInfo {
   smokeTest: boolean;
 }
 
+/** 投递通知到灵动岛时附带的上下文 */
+export interface IslandPushContext {
+  /** 当前是否处于上课时间段（上课期间非紧急通知会被暂存，下课后自动弹出） */
+  inClass?: boolean;
+  /** 当前这节课的结束时间（HH:mm） */
+  currentPeriodEnd?: string | null;
+  week?: number;
+}
+
+export interface IslandClassStatePayload {
+  inClass: boolean;
+  currentPeriodEnd?: string | null;
+  week?: number;
+}
+
 export interface DesktopBridge {
   /** 是否处于冒烟验证模式（由 ELECTRON_SMOKE_TEST=1 触发），同步可读 */
   smokeTest: boolean;
@@ -31,12 +47,29 @@ export interface DesktopBridge {
   clearConfig(): Promise<DesktopStoredConfig>;
   getAppInfo(): Promise<DesktopAppInfo>;
   openExternal(url: string): Promise<boolean>;
+
+  /* 灵动岛 */
+  /** 把一条通知投递到灵动岛 */
+  islandPush(payload: { notification: IslandNotification; context?: IslandPushContext }): void;
+  /** 同步上课状态：进入上课隐藏，下课后自动弹出暂存通知 */
+  islandSetClassState(payload: IslandClassStatePayload): void;
+  /** 读取灵动岛当前状态（设置页/冒烟验证用） */
+  islandGetState(): Promise<IslandState>;
+}
+
+/** 灵动岛窗口自身的桥接（只暴露订阅状态与发送操作） */
+export interface IslandRendererBridge {
+  onState(handler: (state: IslandState) => void): void;
+  sendAction(action: 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app', id?: string): void;
+  getState(): Promise<IslandState>;
 }
 
 declare global {
   interface Window {
     /** 仅在 Electron 中注入；浏览器里为 undefined（渲染进程做了降级处理） */
     desktop?: DesktopBridge;
+    /** 灵动岛窗口专用桥接 */
+    island?: IslandRendererBridge;
     /** 冒烟验证钩子，仅在 ELECTRON_SMOKE_TEST=1 时由渲染进程注册 */
     __classhelperSmoke__?: {
       cacheSelfTest(): Promise<{ ok: boolean; detail: string }>;