@@ -51,6 +51,8 @@ class McpManager {
   /** ELEC2-M1: init 重试计数与定时器（指数退避，环境故障自愈） */
   private retryAttempts = 0;
   private retryTimer: ReturnType<typeof setTimeout> | null = null;
+  /** GW-3(X1): 退出标志——shutdown 发起后禁止再调度 init 重试 */
+  private shuttingDown = false;
   /** 待响应的请求回调 */
   private pending = new Map<string, {
     resolve: (value: unknown) => void;
@@ -135,6 +137,12 @@ class McpManager {
       // ELEC2-M1: 重置 initialized 并指数退避重试——原实现保留 true 导致
       // MCP 功能本次运行永久静默禁用（bridge 故障/环境变量缺失后无自愈机会）
       this.initialized = false;
+      // GW-3(X1): shutdown 已发起时不再调度重试——否则退出窗口期（timer
+      // 回调已触发、init 的 sendRequest in-flight）会 fork 孤儿子进程
+      if (this.shuttingDown) {
+        logger.warn('[MCP] Init failed during shutdown, skip retry scheduling');
+        return;
+      }
       this.scheduleRetryInit();
     }
   }
@@ -205,6 +213,11 @@ class McpManager {
   async shutdown(): Promise<void> {
     logger.info('[MCP] Shutting down MCP Manager...');
 
+    // GW-3(X1): 置位退出标志 + 复位重试计数——in-flight init 失败后不再
+    // 调度重试；重试计数复位防止 dev 热重载重启后直接耗尽
+    this.shuttingDown = true;
+    this.retryAttempts = 0;
+
     // ELEC2-M1: 取消未执行的重试定时器（退出时不再自愈）
     if (this.retryTimer) {
       clearTimeout(this.retryTimer);
 
@@ -2,6 +2,7 @@ import React, { createContext, useContext, useEffect, useState, useCallback, use
 import type { User, Session, AuthError } from '@supabase/supabase-js';
 import { supabase, isPlaceholder } from './supabaseClient';
 import { useToast } from '@/components/ui';
+import { cryptoManager } from '@/lib/crypto';
 
 interface AuthState {
   user: User | null;
@@ -37,6 +38,23 @@ export function AuthProvider({ children }: { children: ReactNode }) {
   /** 标记用户主动登出，避免将主动登出误判为 session 过期 */
   const intentionalSignOutRef = useRef(false);
 
+  // GW-3(X1): 加密初始化接入登录生命周期——init 原无调用方，safeStorage 加密
+  // 路径从未激活（敏感字段恒明文写入）。登录成功后派生设备级 AES 密钥
+  //（Electron 环境经 safeStorage 加密落盘），登出/未登录时清除密钥。
+  // init 失败时显式提示（已置 initFailed 标记），不静默降级为明文
+  useEffect(() => {
+    const userId = state.user?.id;
+    if (userId) {
+      cryptoManager.init(userId).catch((err) => {
+        console.warn('[Auth] CryptoManager init failed, sensitive fields will be stored in plaintext:', err);
+        toast({ type: 'warning', message: '本地加密初始化失败，敏感字段将以明文存储' });
+      });
+    } else {
+      cryptoManager.clear();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [state.user?.id]);
+
   useEffect(() => {
     supabase.auth.getSession().then(({ data: { session } }) => {
       setState({
 
@@ -7,66 +7,11 @@
  * 绕过类型（根治优于局部断言）。
  * @ai-context: invoke/on/send 为通配逃生通道，新增 IPC 能力应优先
  * 定义精确的具名方法而非走通配 invoke。
+ *
+ * GW-3(X2): Window.electronAPI 的唯一权威声明已并入 src/env.d.ts
+ *（该文件为超集：含 recording/ollama/audio_capture/ai_progress_narrate 等
+ * 全部新 API）。本文件保留空壳仅维持旧导入路径兼容——双份声明曾多处
+ * 类型冲突（必选/可选、返回类型不一致），被 skipLibCheck 掩盖。
  */
 
 export {};
-
-declare global {
-  interface Window {
-    electronAPI?: {
-      invoke: (channel: string, ...args: unknown[]) => Promise<unknown>;
-      on: (channel: string, callback: (...args: unknown[]) => void) => () => void;
-      send: (channel: string, ...args: unknown[]) => void;
-      /** 拖拽文件 → 绝对路径（知识入籍 PDF 拖拽，Electron 35 webUtils） */
-      getPathForFile: (file: File) => string;
-      /** 监听主进程发出的窗口关闭事件，返回取消监听函数 */
-      onWindowClosing: (callback: () => void) => () => void;
-      /** 向主进程发送关闭行为选择 */
-      closeAction: (action: 'quit' | 'minimize' | 'cancel', remember: boolean) => Promise<void>;
-      /** 最小化窗口 */
-      windowMinimize: () => Promise<{ success: boolean }>;
-      /** 切换最大化/还原 */
-      windowMaximize: () => Promise<{ success: boolean }>;
-      /** 关闭窗口（触发确认流程） */
-      windowClose: () => Promise<{ success: boolean }>;
-      /** 查询当前是否最大化 */
-      windowIsMaximized: () => Promise<boolean>;
-      /** 监听最大化状态变化，返回取消监听函数 */
-      onMaximizedChanged: (callback: (isMaximized: boolean) => void) => () => void;
-      /** 监听退出前同步事件，返回取消监听函数 */
-      onSyncBeforeQuit: (callback: () => void) => () => void;
-      /** 通知主进程同步完成 */
-      notifySyncComplete: () => void;
-      /** 设置是否自动检查更新 */
-      setAutoUpdate: (enabled: boolean) => Promise<{ success: boolean }>;
-      /** FRONT2-M5: safeStorage 系统级加密（密钥材料落盘保护） */
-      safeStorageEncrypt: (plain: string) => Promise<string>;
-      safeStorageDecrypt: (encoded: string) => Promise<string>;
-      /** v1.0.0: 数据访问 API */
-      db: {
-        query: <T = unknown>(table: string, method: string, args?: unknown[]) => Promise<T>;
-        insert: (table: string, item: unknown) => Promise<string>;
-        update: (table: string, id: string, changes: unknown) => Promise<void>;
-        delete: (table: string, id: string) => Promise<void>;
-        search: <T = unknown>(table: string, query: string) => Promise<T[]>;
-        batch: (operations: unknown[]) => Promise<{ success: boolean }>;
-      };
-      /** v1.0.0: 数据迁移 API */
-      migration: {
-        check: () => Promise<{ needed: boolean; tableMapping: Array<{ dexie: string; sqlite: string }> }>;
-        importTable: (table: string, rows: unknown[]) => Promise<{ success: boolean; rowsImported: number; error?: string }>;
-        complete: () => Promise<{ success: boolean; integrity: string; error?: string }>;
-      };
-      /** v1.1.0: 存储路径管理 API */
-      storage: {
-        changePath: (newPath: string) => Promise<{
-          success: boolean;
-          previousPath?: string;
-          newPath?: string;
-          error?: string;
-        }>;
-        getActivePath: () => Promise<string>;
-      };
-    };
-  }
-}
@@ -111,6 +111,8 @@
 # GW-2#9: 启动校验——PATH_TO_FEATURE 登记的 feature 必须同时在
 # TIMEOUT_CONFIG 与 RATE_LIMITS 登记，否则静默兜底（300s 超时/默认 10 次限流）
 # 会掩盖配置缺失（import_concept 曾因此落入 300s 超时预算）
+# GW-3(X6): 校验提取为公共函数——流式路由（/{feature}/stream）的
+# _FEATURE_TO_CONFIG_KEY 注册表同样调用，覆盖此前校验盲区
 _MISSING_CONFIG = sorted(
     f for f in set(PATH_TO_FEATURE.values())
     if f not in RATE_LIMITS or f not in TIMEOUT_CONFIG
@@ -122,6 +124,20 @@
     )
 
 
+def warn_missing_feature_config(features: set[str], source: str) -> None:
+    """GW-3(X6): 校验一组 feature 是否同时登记 TIMEOUT_CONFIG 与 RATE_LIMITS。
+
+    中间件（PATH_TO_FEATURE）与流式路由（_FEATURE_TO_CONFIG_KEY）共用本函数，
+    新增功能漏配时启动即告警，避免静默落入 300s 兜底超时/默认 10 次限流。
+    """
+    missing = sorted(f for f in features if f not in RATE_LIMITS or f not in TIMEOUT_CONFIG)
+    if missing:
+        logger.warning(
+            "[%s] 以下 feature 缺少 TIMEOUT_CONFIG/RATE_LIMITS 登记（将使用兜底值）: %s",
+            source, missing,
+        )
+
+
 class RateLimitMiddleware(BaseHTTPMiddleware):
     """频率限制中间件 — 基于 Redis 滑动窗口"""
 
 
@@ -126,6 +126,9 @@ async def generate(
                     cache_miss_tokens = prompt_tokens - cache_hit_tokens
                     # DeepSeek 缓存命中按 1/4 价格计费
                     effective_tokens = int(cache_hit_tokens * 0.25) + cache_miss_tokens + completion_tokens
+                    # GW-3(X4): input 记账改用缓存未命中部分（命中部分按 1/4
+                    # 计费）——原实现用原始 prompt_tokens，缓存命中场景成本高估
+                    input_tokens = cache_miss_tokens
                     logger.info(
                         "DeepSeek 缓存命中: hit=%d, miss=%d, 实际计费 token=%d",
                         cache_hit_tokens, cache_miss_tokens, effective_tokens,
 
@@ -143,11 +143,17 @@ async def generate_vision(
             latency_ms = int((time.monotonic() - start_time) * 1000)
             content = response.text or ""
             tokens_used = 0
+            input_tokens = 0
+            output_tokens = 0
             if response.usage_metadata:
                 tokens_used = response.usage_metadata.total_token_count or 0
+                # GW-3(X4): 视觉路径同样返回 input/output 拆分供成本记账
+                input_tokens = getattr(response.usage_metadata, "prompt_token_count", 0) or 0
+                output_tokens = getattr(response.usage_metadata, "candidates_token_count", 0) or 0
             logger.info("GeminiProvider.generate_vision 成功: model=%s, tokens=%d, latency=%dms",
                         model, tokens_used, latency_ms)
             return {"content": content, "tokens_used": tokens_used,
+                    "input_tokens": input_tokens, "output_tokens": output_tokens,
                     "model": model, "latency_ms": latency_ms}
         except Exception as e:
             logger.error("GeminiProvider.generate_vision 失败: %s", str(e))
@@ -194,11 +200,17 @@ async def generate_vision_multi(
             latency_ms = int((time.monotonic() - start_time) * 1000)
             content = response.text or ""
             tokens_used = 0
+            input_tokens = 0
+            output_tokens = 0
             if response.usage_metadata:
                 tokens_used = response.usage_metadata.total_token_count or 0
+                # GW-3(X4): 多图路径同样返回 input/output 拆分供成本记账
+                input_tokens = getattr(response.usage_metadata, "prompt_token_count", 0) or 0
+                output_tokens = getattr(response.usage_metadata, "candidates_token_count", 0) or 0
             logger.info("GeminiProvider.generate_vision_multi 成功: model=%s, images=%d, tokens=%d, latency=%dms",
                         model, len(images_base64), tokens_used, latency_ms)
             return {"content": content, "tokens_used": tokens_used,
+                    "input_tokens": input_tokens, "output_tokens": output_tokens,
                     "model": model, "latency_ms": latency_ms}
         except Exception as e:
             logger.error("GeminiProvider.generate_vision_multi 失败: %s", str(e))
@@ -261,11 +273,17 @@ async def generate_video(
             latency_ms = int((time.monotonic() - start_time) * 1000)
             content = response.text or ""
             tokens_used = 0
+            input_tokens = 0
+            output_tokens = 0
             if response.usage_metadata:
                 tokens_used = response.usage_metadata.total_token_count or 0
+                # GW-3(X4): 视频路径同样返回 input/output 拆分供成本记账
+                input_tokens = getattr(response.usage_metadata, "prompt_token_count", 0) or 0
+                output_tokens = getattr(response.usage_metadata, "candidates_token_count", 0) or 0
             logger.info("GeminiProvider.generate_video 成功: model=%s, tokens=%d, latency=%dms",
                         model, tokens_used, latency_ms)
             return {"content": content, "tokens_used": tokens_used,
+                    "input_tokens": input_tokens, "output_tokens": output_tokens,
                     "model": model, "latency_ms": latency_ms}
         except Exception as e:
             logger.error("GeminiProvider.generate_video 失败: %s", str(e))
 
@@ -137,9 +137,12 @@ async def error_pattern(request: Request, body: ErrorPatternRequest) -> ErrorPat
     # GW-2#10: 缓存键加入 user_id 隔离——错误模式分析结果基于用户私有
     # 学习数据，原键不含用户维度，内容相同的不同用户会串用彼此的分析结论
     #（隐私泄露 + 正确性错误）；同时不再截断 50 字符（sha256 本身压缩长度）
+    # GW-3(X5): 键仅含 chain 实际消费的字段（前 20 条 correctAnswer/userAnswer，
+    # flashcardId 不参与分析）——原键含 flashcardId 与全量文本，同内容不同
+    # flashcardId 不命中缓存，命中率低（多付 AI 调用成本）
     errors_str = "|".join([
-        f"{e.flashcardId}:{e.correctAnswer}:{e.userAnswer}"
-        for e in body.goldenErrors
+        f"{e.correctAnswer}:{e.userAnswer}"
+        for e in body.goldenErrors[:20]
     ])
     cache_key = hashlib.sha256(f"{user_id}:{errors_str}".encode()).hexdigest()
 
 
@@ -24,7 +24,7 @@
 from pydantic import BaseModel, Field
 
 from config import call_with_fallback_stream
-from middleware.rate_limit import check_rate_limit
+from middleware.rate_limit import check_rate_limit, warn_missing_feature_config
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/v1/ai", tags=["流式输出"])
@@ -165,6 +165,10 @@
     "inspiration-draft": "inspiration_draft",
 }
 
+# GW-3(X6): 启动校验——流式 feature 同样必须登记 TIMEOUT_CONFIG/RATE_LIMITS
+#（原校验只覆盖中间件 PATH_TO_FEATURE，流式注册表漏配不告警）
+warn_missing_feature_config(set(_FEATURE_TO_CONFIG_KEY.values()), "streaming")
+
 
 # ============================================================
 # 通用请求体（流式请求统一使用）