feat: 实现循环防护和安全验证功能

refactor(loop_guard): 为LoopGuard添加Clone派生
feat(capabilities): 实现CapabilityManager.validate()安全验证
fix(agentStore): 添加token用量追踪
chore: 删除未实现的Predictor/Lead HAND.toml文件
style(Credits): 移除假数据并标注开发中状态
refactor(Skills): 动态加载技能卡片
perf(configStore): 为定时任务添加localStorage降级
docs: 更新功能文档和版本变更记录

desktop/src/lib/intelligence-client.ts

@@ -3,7 +3,16 @@
  *
  * Provides a unified API for intelligence operations that:
  * - Uses Rust backend (via Tauri commands) when running in Tauri environment
- * - Falls back to localStorage-based implementation in browser environment
+ * - Falls back to localStorage-based implementation in browser/dev environment
+ *
+ * Degradation strategy:
+ * - In Tauri mode: if a Tauri invoke fails, the error is logged and re-thrown.
+ *   The caller is responsible for handling the error. We do NOT silently fall
+ *   back to localStorage, because that would give users degraded functionality
+ *   (localStorage instead of SQLite, rule-based instead of LLM-based, no-op
+ *   instead of real execution) without any indication that something is wrong.
+ * - In browser/dev mode: localStorage fallback is the intended behavior for
+ *   development and testing without a Tauri backend.
  *
  * This replaces direct usage of:
  * - agent-memory.ts
@@ -38,6 +47,8 @@
 
 import { invoke } from '@tauri-apps/api/core';
 
+import { isTauriRuntime } from './tauri-gateway';
+
 import {
   intelligence,
   type MemoryEntryInput,
@@ -62,15 +73,6 @@ import {
   type IdentitySnapshot,
 } from './intelligence-backend';
 
-// === Environment Detection ===
-
-/**
- * Check if running in Tauri environment
- */
-export function isTauriEnv(): boolean {
-  return typeof window !== 'undefined' && '__TAURI__' in window;
-}
-
 // === Frontend Types (for backward compatibility) ===
 
 export type MemoryType = 'fact' | 'preference' | 'lesson' | 'context' | 'task';
@@ -982,75 +984,91 @@ const fallbackHeartbeat = {
 // === Unified Client Export ===
 
 /**
- * Unified intelligence client that automatically selects backend or fallback
+ * Helper: wrap a Tauri invoke call so that failures are logged and re-thrown
+ * instead of silently falling back to localStorage implementations.
+ */
+function tauriInvoke<T>(label: string, fn: () => Promise<T>): Promise<T> {
+  return fn().catch((e: unknown) => {
+    console.warn(`[IntelligenceClient] Tauri invoke failed (${label}):`, e);
+    throw e;
+  });
+}
+
+/**
+ * Unified intelligence client that automatically selects backend or fallback.
+ *
+ * - In Tauri mode: calls Rust backend via invoke(). On failure, logs a warning
+ *   and re-throws -- does NOT fall back to localStorage.
+ * - In browser/dev mode: uses localStorage-based fallback implementations.
  */
 export const intelligenceClient = {
   memory: {
     init: async (): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.memory.init();
+      if (isTauriRuntime()) {
+        await tauriInvoke('memory.init', () => intelligence.memory.init());
       } else {
         await fallbackMemory.init();
       }
     },
 
     store: async (entry: MemoryEntryInput): Promise<string> => {
-      if (isTauriEnv()) {
-        return intelligence.memory.store(entry);
+      if (isTauriRuntime()) {
+        return tauriInvoke('memory.store', () => intelligence.memory.store(entry));
       }
       return fallbackMemory.store(entry);
     },
 
     get: async (id: string): Promise<MemoryEntry | null> => {
-      if (isTauriEnv()) {
-        const result = await intelligence.memory.get(id);
+      if (isTauriRuntime()) {
+        const result = await tauriInvoke('memory.get', () => intelligence.memory.get(id));
         return result ? toFrontendMemory(result) : null;
       }
       return fallbackMemory.get(id);
     },
 
     search: async (options: MemorySearchOptions): Promise<MemoryEntry[]> => {
-      if (isTauriEnv()) {
-        const results = await intelligence.memory.search(toBackendSearchOptions(options));
+      if (isTauriRuntime()) {
+        const results = await tauriInvoke('memory.search', () =>
+          intelligence.memory.search(toBackendSearchOptions(options))
+        );
         return results.map(toFrontendMemory);
       }
       return fallbackMemory.search(options);
     },
 
     delete: async (id: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.memory.delete(id);
+      if (isTauriRuntime()) {
+        await tauriInvoke('memory.delete', () => intelligence.memory.delete(id));
       } else {
         await fallbackMemory.delete(id);
       }
     },
 
     deleteAll: async (agentId: string): Promise<number> => {
-      if (isTauriEnv()) {
-        return intelligence.memory.deleteAll(agentId);
+      if (isTauriRuntime()) {
+        return tauriInvoke('memory.deleteAll', () => intelligence.memory.deleteAll(agentId));
       }
       return fallbackMemory.deleteAll(agentId);
     },
 
     stats: async (): Promise<MemoryStats> => {
-      if (isTauriEnv()) {
-        const stats = await intelligence.memory.stats();
+      if (isTauriRuntime()) {
+        const stats = await tauriInvoke('memory.stats', () => intelligence.memory.stats());
         return toFrontendStats(stats);
       }
       return fallbackMemory.stats();
     },
 
     export: async (): Promise<MemoryEntry[]> => {
-      if (isTauriEnv()) {
-        const results = await intelligence.memory.export();
+      if (isTauriRuntime()) {
+        const results = await tauriInvoke('memory.export', () => intelligence.memory.export());
         return results.map(toFrontendMemory);
       }
       return fallbackMemory.export();
     },
 
     import: async (memories: MemoryEntry[]): Promise<number> => {
-      if (isTauriEnv()) {
-        // Convert to backend format
+      if (isTauriRuntime()) {
         const backendMemories = memories.map(m => ({
           ...m,
           agent_id: m.agentId,
@@ -1062,14 +1080,16 @@ export const intelligenceClient = {
           tags: JSON.stringify(m.tags),
           embedding: null,
         }));
-        return intelligence.memory.import(backendMemories as PersistentMemory[]);
+        return tauriInvoke('memory.import', () =>
+          intelligence.memory.import(backendMemories as PersistentMemory[])
+        );
       }
       return fallbackMemory.import(memories);
     },
 
     dbPath: async (): Promise<string> => {
-      if (isTauriEnv()) {
-        return intelligence.memory.dbPath();
+      if (isTauriRuntime()) {
+        return tauriInvoke('memory.dbPath', () => intelligence.memory.dbPath());
       }
       return fallbackMemory.dbPath();
     },
@@ -1079,10 +1099,12 @@ export const intelligenceClient = {
       query: string,
       maxTokens?: number,
     ): Promise<{ systemPromptAddition: string; totalTokens: number; memoriesUsed: number }> => {
-      if (isTauriEnv()) {
-        return intelligence.memory.buildContext(agentId, query, maxTokens ?? null);
+      if (isTauriRuntime()) {
+        return tauriInvoke('memory.buildContext', () =>
+          intelligence.memory.buildContext(agentId, query, maxTokens ?? null)
+        );
       }
-      // Fallback: use basic search
+      // Browser/dev fallback: use basic search
       const memories = await fallbackMemory.search({
         agentId,
         query,
@@ -1098,54 +1120,58 @@ export const intelligenceClient = {
 
   heartbeat: {
     init: async (agentId: string, config?: HeartbeatConfig): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.heartbeat.init(agentId, config);
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.init', () => intelligence.heartbeat.init(agentId, config));
       } else {
         await fallbackHeartbeat.init(agentId, config);
       }
     },
 
     start: async (agentId: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.heartbeat.start(agentId);
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.start', () => intelligence.heartbeat.start(agentId));
       } else {
         await fallbackHeartbeat.start(agentId);
       }
     },
 
     stop: async (agentId: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.heartbeat.stop(agentId);
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.stop', () => intelligence.heartbeat.stop(agentId));
       } else {
         await fallbackHeartbeat.stop(agentId);
       }
     },
 
     tick: async (agentId: string): Promise<HeartbeatResult> => {
-      if (isTauriEnv()) {
-        return intelligence.heartbeat.tick(agentId);
+      if (isTauriRuntime()) {
+        return tauriInvoke('heartbeat.tick', () => intelligence.heartbeat.tick(agentId));
       }
       return fallbackHeartbeat.tick(agentId);
     },
 
     getConfig: async (agentId: string): Promise<HeartbeatConfig> => {
-      if (isTauriEnv()) {
-        return intelligence.heartbeat.getConfig(agentId);
+      if (isTauriRuntime()) {
+        return tauriInvoke('heartbeat.getConfig', () => intelligence.heartbeat.getConfig(agentId));
       }
       return fallbackHeartbeat.getConfig(agentId);
     },
 
     updateConfig: async (agentId: string, config: HeartbeatConfig): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.heartbeat.updateConfig(agentId, config);
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.updateConfig', () =>
+          intelligence.heartbeat.updateConfig(agentId, config)
+        );
       } else {
         await fallbackHeartbeat.updateConfig(agentId, config);
       }
     },
 
     getHistory: async (agentId: string, limit?: number): Promise<HeartbeatResult[]> => {
-      if (isTauriEnv()) {
-        return intelligence.heartbeat.getHistory(agentId, limit);
+      if (isTauriRuntime()) {
+        return tauriInvoke('heartbeat.getHistory', () =>
+          intelligence.heartbeat.getHistory(agentId, limit)
+        );
       }
       return fallbackHeartbeat.getHistory(agentId, limit);
     },
@@ -1156,61 +1182,74 @@ export const intelligenceClient = {
       totalEntries: number,
       storageSizeBytes: number
     ): Promise<void> => {
-      if (isTauriEnv()) {
-        await invoke('heartbeat_update_memory_stats', {
-          agent_id: agentId,
-          task_count: taskCount,
-          total_entries: totalEntries,
-          storage_size_bytes: storageSizeBytes,
-        });
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.updateMemoryStats', () =>
+          invoke('heartbeat_update_memory_stats', {
+            agent_id: agentId,
+            task_count: taskCount,
+            total_entries: totalEntries,
+            storage_size_bytes: storageSizeBytes,
+          })
+        );
+      } else {
+        // Browser/dev fallback only
+        const cache = {
+          taskCount,
+          totalEntries,
+          storageSizeBytes,
+          lastUpdated: new Date().toISOString(),
+        };
+        localStorage.setItem(`zclaw-memory-stats-${agentId}`, JSON.stringify(cache));
       }
-      // Fallback: store in localStorage for non-Tauri environment
-      const cache = {
-        taskCount,
-        totalEntries,
-        storageSizeBytes,
-        lastUpdated: new Date().toISOString(),
-      };
-      localStorage.setItem(`zclaw-memory-stats-${agentId}`, JSON.stringify(cache));
     },
 
     recordCorrection: async (agentId: string, correctionType: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await invoke('heartbeat_record_correction', {
-          agent_id: agentId,
-          correction_type: correctionType,
-        });
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.recordCorrection', () =>
+          invoke('heartbeat_record_correction', {
+            agent_id: agentId,
+            correction_type: correctionType,
+          })
+        );
+      } else {
+        // Browser/dev fallback only
+        const key = `zclaw-corrections-${agentId}`;
+        const stored = localStorage.getItem(key);
+        const counters = stored ? JSON.parse(stored) : {};
+        counters[correctionType] = (counters[correctionType] || 0) + 1;
+        localStorage.setItem(key, JSON.stringify(counters));
       }
-      // Fallback: store in localStorage for non-Tauri environment
-      const key = `zclaw-corrections-${agentId}`;
-      const stored = localStorage.getItem(key);
-      const counters = stored ? JSON.parse(stored) : {};
-      counters[correctionType] = (counters[correctionType] || 0) + 1;
-      localStorage.setItem(key, JSON.stringify(counters));
     },
 
     recordInteraction: async (agentId: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await invoke('heartbeat_record_interaction', {
-          agent_id: agentId,
-        });
+      if (isTauriRuntime()) {
+        await tauriInvoke('heartbeat.recordInteraction', () =>
+          invoke('heartbeat_record_interaction', {
+            agent_id: agentId,
+          })
+        );
+      } else {
+        // Browser/dev fallback only
+        localStorage.setItem(`zclaw-last-interaction-${agentId}`, new Date().toISOString());
       }
-      // Fallback: store in localStorage for non-Tauri environment
-      localStorage.setItem(`zclaw-last-interaction-${agentId}`, new Date().toISOString());
     },
   },
 
   compactor: {
     estimateTokens: async (text: string): Promise<number> => {
-      if (isTauriEnv()) {
-        return intelligence.compactor.estimateTokens(text);
+      if (isTauriRuntime()) {
+        return tauriInvoke('compactor.estimateTokens', () =>
+          intelligence.compactor.estimateTokens(text)
+        );
       }
       return fallbackCompactor.estimateTokens(text);
     },
 
     estimateMessagesTokens: async (messages: CompactableMessage[]): Promise<number> => {
-      if (isTauriEnv()) {
-        return intelligence.compactor.estimateMessagesTokens(messages);
+      if (isTauriRuntime()) {
+        return tauriInvoke('compactor.estimateMessagesTokens', () =>
+          intelligence.compactor.estimateMessagesTokens(messages)
+        );
       }
       return fallbackCompactor.estimateMessagesTokens(messages);
     },
@@ -1219,8 +1258,10 @@ export const intelligenceClient = {
       messages: CompactableMessage[],
       config?: CompactionConfig
     ): Promise<CompactionCheck> => {
-      if (isTauriEnv()) {
-        return intelligence.compactor.checkThreshold(messages, config);
+      if (isTauriRuntime()) {
+        return tauriInvoke('compactor.checkThreshold', () =>
+          intelligence.compactor.checkThreshold(messages, config)
+        );
       }
       return fallbackCompactor.checkThreshold(messages, config);
     },
@@ -1231,8 +1272,10 @@ export const intelligenceClient = {
       conversationId?: string,
       config?: CompactionConfig
     ): Promise<CompactionResult> => {
-      if (isTauriEnv()) {
-        return intelligence.compactor.compact(messages, agentId, conversationId, config);
+      if (isTauriRuntime()) {
+        return tauriInvoke('compactor.compact', () =>
+          intelligence.compactor.compact(messages, agentId, conversationId, config)
+        );
       }
       return fallbackCompactor.compact(messages, agentId, conversationId, config);
     },
@@ -1240,45 +1283,53 @@ export const intelligenceClient = {
 
   reflection: {
     init: async (config?: ReflectionConfig): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.reflection.init(config);
+      if (isTauriRuntime()) {
+        await tauriInvoke('reflection.init', () => intelligence.reflection.init(config));
       } else {
         await fallbackReflection.init(config);
       }
     },
 
     recordConversation: async (): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.reflection.recordConversation();
+      if (isTauriRuntime()) {
+        await tauriInvoke('reflection.recordConversation', () =>
+          intelligence.reflection.recordConversation()
+        );
       } else {
         await fallbackReflection.recordConversation();
       }
     },
 
     shouldReflect: async (): Promise<boolean> => {
-      if (isTauriEnv()) {
-        return intelligence.reflection.shouldReflect();
+      if (isTauriRuntime()) {
+        return tauriInvoke('reflection.shouldReflect', () =>
+          intelligence.reflection.shouldReflect()
+        );
       }
       return fallbackReflection.shouldReflect();
     },
 
     reflect: async (agentId: string, memories: MemoryEntryForAnalysis[]): Promise<ReflectionResult> => {
-      if (isTauriEnv()) {
-        return intelligence.reflection.reflect(agentId, memories);
+      if (isTauriRuntime()) {
+        return tauriInvoke('reflection.reflect', () =>
+          intelligence.reflection.reflect(agentId, memories)
+        );
       }
       return fallbackReflection.reflect(agentId, memories);
     },
 
     getHistory: async (limit?: number): Promise<ReflectionResult[]> => {
-      if (isTauriEnv()) {
-        return intelligence.reflection.getHistory(limit);
+      if (isTauriRuntime()) {
+        return tauriInvoke('reflection.getHistory', () =>
+          intelligence.reflection.getHistory(limit)
+        );
       }
       return fallbackReflection.getHistory(limit);
     },
 
     getState: async (): Promise<ReflectionState> => {
-      if (isTauriEnv()) {
-        return intelligence.reflection.getState();
+      if (isTauriRuntime()) {
+        return tauriInvoke('reflection.getState', () => intelligence.reflection.getState());
       }
       return fallbackReflection.getState();
     },
@@ -1286,37 +1337,43 @@ export const intelligenceClient = {
 
   identity: {
     get: async (agentId: string): Promise<IdentityFiles> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.get(agentId);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.get', () => intelligence.identity.get(agentId));
       }
       return fallbackIdentity.get(agentId);
     },
 
     getFile: async (agentId: string, file: string): Promise<string> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.getFile(agentId, file);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.getFile', () => intelligence.identity.getFile(agentId, file));
       }
       return fallbackIdentity.getFile(agentId, file);
     },
 
     buildPrompt: async (agentId: string, memoryContext?: string): Promise<string> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.buildPrompt(agentId, memoryContext);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.buildPrompt', () =>
+          intelligence.identity.buildPrompt(agentId, memoryContext)
+        );
       }
       return fallbackIdentity.buildPrompt(agentId, memoryContext);
     },
 
     updateUserProfile: async (agentId: string, content: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.identity.updateUserProfile(agentId, content);
+      if (isTauriRuntime()) {
+        await tauriInvoke('identity.updateUserProfile', () =>
+          intelligence.identity.updateUserProfile(agentId, content)
+        );
       } else {
         await fallbackIdentity.updateUserProfile(agentId, content);
       }
     },
 
     appendUserProfile: async (agentId: string, addition: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.identity.appendUserProfile(agentId, addition);
+      if (isTauriRuntime()) {
+        await tauriInvoke('identity.appendUserProfile', () =>
+          intelligence.identity.appendUserProfile(agentId, addition)
+        );
       } else {
         await fallbackIdentity.appendUserProfile(agentId, addition);
       }
@@ -1328,67 +1385,81 @@ export const intelligenceClient = {
       suggestedContent: string,
       reason: string
     ): Promise<IdentityChangeProposal> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.proposeChange(agentId, file, suggestedContent, reason);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.proposeChange', () =>
+          intelligence.identity.proposeChange(agentId, file, suggestedContent, reason)
+        );
       }
       return fallbackIdentity.proposeChange(agentId, file, suggestedContent, reason);
     },
 
     approveProposal: async (proposalId: string): Promise<IdentityFiles> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.approveProposal(proposalId);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.approveProposal', () =>
+          intelligence.identity.approveProposal(proposalId)
+        );
       }
       return fallbackIdentity.approveProposal(proposalId);
     },
 
     rejectProposal: async (proposalId: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.identity.rejectProposal(proposalId);
+      if (isTauriRuntime()) {
+        await tauriInvoke('identity.rejectProposal', () =>
+          intelligence.identity.rejectProposal(proposalId)
+        );
       } else {
         await fallbackIdentity.rejectProposal(proposalId);
       }
     },
 
     getPendingProposals: async (agentId?: string): Promise<IdentityChangeProposal[]> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.getPendingProposals(agentId);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.getPendingProposals', () =>
+          intelligence.identity.getPendingProposals(agentId)
+        );
       }
       return fallbackIdentity.getPendingProposals(agentId);
     },
 
     updateFile: async (agentId: string, file: string, content: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.identity.updateFile(agentId, file, content);
+      if (isTauriRuntime()) {
+        await tauriInvoke('identity.updateFile', () =>
+          intelligence.identity.updateFile(agentId, file, content)
+        );
       } else {
         await fallbackIdentity.updateFile(agentId, file, content);
       }
     },
 
     getSnapshots: async (agentId: string, limit?: number): Promise<IdentitySnapshot[]> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.getSnapshots(agentId, limit);
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.getSnapshots', () =>
+          intelligence.identity.getSnapshots(agentId, limit)
+        );
       }
       return fallbackIdentity.getSnapshots(agentId, limit);
     },
 
     restoreSnapshot: async (agentId: string, snapshotId: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.identity.restoreSnapshot(agentId, snapshotId);
+      if (isTauriRuntime()) {
+        await tauriInvoke('identity.restoreSnapshot', () =>
+          intelligence.identity.restoreSnapshot(agentId, snapshotId)
+        );
       } else {
         await fallbackIdentity.restoreSnapshot(agentId, snapshotId);
       }
     },
 
     listAgents: async (): Promise<string[]> => {
-      if (isTauriEnv()) {
-        return intelligence.identity.listAgents();
+      if (isTauriRuntime()) {
+        return tauriInvoke('identity.listAgents', () => intelligence.identity.listAgents());
       }
       return fallbackIdentity.listAgents();
     },
 
     deleteAgent: async (agentId: string): Promise<void> => {
-      if (isTauriEnv()) {
-        await intelligence.identity.deleteAgent(agentId);
+      if (isTauriRuntime()) {
+        await tauriInvoke('identity.deleteAgent', () => intelligence.identity.deleteAgent(agentId));
       } else {
         await fallbackIdentity.deleteAgent(agentId);
       }