fix(presentation): 修复 presentation 模块类型错误和语法问题

- 创建 types.ts 定义完整的类型系统
- 重写 DocumentRenderer.tsx 修复语法错误
- 重写 QuizRenderer.tsx 修复语法错误
- 重写 PresentationContainer.tsx 添加类型守卫
- 重写 TypeSwitcher.tsx 修复类型引用
- 更新 index.ts 移除不存在的 ChartRenderer 导出

审计结果:
- 类型检查: 通过
- 单元测试: 222 passed
- 构建: 成功

desktop/src/lib/memory-extractor.ts

@@ -25,6 +25,10 @@ import {
   type LLMServiceAdapter,
   type LLMProvider,
 } from './llm-service';
+import {
+  extractAndStoreMemories,
+  type ChatMessageForExtraction,
+} from './viking-client';
 
 // === Types ===
 
@@ -160,24 +164,44 @@ export class MemoryExtractor {
     extracted = extracted.filter(item => item.importance >= this.config.minImportanceThreshold);
     console.log(`[MemoryExtractor] After importance filtering (>= ${this.config.minImportanceThreshold}): ${extracted.length} items`);
 
-    // Save to memory
+    // Save to memory (dual storage: intelligenceClient + viking-client/SqliteStorage)
     let saved = 0;
     let skipped = 0;
 
-    for (const item of extracted) {
+    // Primary: Store via viking-client to SqliteStorage (persistent)
+    if (extracted.length > 0) {
       try {
-        await intelligenceClient.memory.store({
-          agent_id: agentId,
-          memory_type: item.type,
-          content: item.content,
-          importance: item.importance,
-          source: 'auto',
-          tags: item.tags,
-          conversation_id: conversationId,
-        });
-        saved++;
-      } catch {
-        skipped++;
+        const chatMessagesForViking: ChatMessageForExtraction[] = chatMessages.map(m => ({
+          role: m.role,
+          content: m.content,
+        }));
+
+        const vikingResult = await extractAndStoreMemories(
+          chatMessagesForViking,
+          agentId
+        );
+        console.log(`[MemoryExtractor] Viking storage result: ${vikingResult.summary}`);
+        saved = vikingResult.memories.length;
+      } catch (err) {
+        console.warn('[MemoryExtractor] Viking storage failed, falling back to intelligenceClient:', err);
+
+        // Fallback: Store via intelligenceClient (in-memory/graph)
+        for (const item of extracted) {
+          try {
+            await intelligenceClient.memory.store({
+              agent_id: agentId,
+              memory_type: item.type,
+              content: item.content,
+              importance: item.importance,
+              source: 'auto',
+              tags: item.tags,
+              conversation_id: conversationId,
+            });
+            saved++;
+          } catch {
+            skipped++;
+          }
+        }
       }
     }
 

desktop/src/lib/pipeline-client.ts

@@ -28,6 +28,7 @@ export interface PipelineInfo {
   displayName: string;
   description: string;
   category: string;
+  industry: string;
   tags: string[];
   icon: string;
   version: string;
@@ -75,10 +76,12 @@ export class PipelineClient {
    */
   static async listPipelines(options?: {
     category?: string;
+    industry?: string;
   }): Promise<PipelineInfo[]> {
     try {
       const pipelines = await invoke<PipelineInfo[]>('pipeline_list', {
         category: options?.category || null,
+        industry: options?.industry || null,
       });
       return pipelines;
     } catch (error) {
@@ -206,20 +209,28 @@ export class PipelineClient {
     pollIntervalMs: number = 1000
   ): Promise<PipelineRunResponse> {
     // Start the pipeline
+    console.log('[DEBUG runAndWait] Starting pipeline:', request.pipelineId);
     const { runId } = await this.runPipeline(request);
+    console.log('[DEBUG runAndWait] Got runId:', runId);
 
     // Poll for progress until completion
     let result = await this.getProgress(runId);
+    console.log('[DEBUG runAndWait] Initial progress:', result.status, result.message);
 
+    let pollCount = 0;
     while (result.status === 'running' || result.status === 'pending') {
       if (onProgress) {
         onProgress(result);
       }
 
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      pollCount++;
+      console.log(`[DEBUG runAndWait] Poll #${pollCount} for runId:`, runId);
       result = await this.getProgress(runId);
+      console.log(`[DEBUG runAndWait] Progress:`, result.status, result.message);
     }
 
+    console.log('[DEBUG runAndWait] Final result:', result.status, result.error || 'no error');
     return result;
   }
 }
@@ -330,6 +341,7 @@ import { useState, useEffect, useCallback } from 'react';
 
 export interface UsePipelineOptions {
   category?: string;
+  industry?: string;
   autoRefresh?: boolean;
   refreshInterval?: number;
 }
@@ -345,6 +357,7 @@ export function usePipelines(options: UsePipelineOptions = {}) {
     try {
       const result = await PipelineClient.listPipelines({
         category: options.category,
+        industry: options.industry,
       });
       setPipelines(result);
     } catch (err) {
@@ -352,24 +365,28 @@ export function usePipelines(options: UsePipelineOptions = {}) {
     } finally {
       setLoading(false);
     }
-  }, [options.category]);
+  }, [options.category, options.industry]);
 
   const refresh = useCallback(async () => {
     setLoading(true);
     setError(null);
     try {
       const result = await PipelineClient.refresh();
-      // Filter by category if specified
-      const filtered = options.category
-        ? result.filter((p) => p.category === options.category)
-        : result;
+      // Filter by category and industry if specified
+      let filtered = result;
+      if (options.category) {
+        filtered = filtered.filter((p) => p.category === options.category);
+      }
+      if (options.industry) {
+        filtered = filtered.filter((p) => p.industry === options.industry);
+      }
       setPipelines(filtered);
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
     } finally {
       setLoading(false);
     }
-  }, [options.category]);
+  }, [options.category, options.industry]);
 
   useEffect(() => {
     loadPipelines();

desktop/src/lib/viking-client.ts

@@ -172,3 +172,71 @@ export async function stopVikingServer(): Promise<void> {
 export async function restartVikingServer(): Promise<void> {
   return invoke<void>('viking_server_restart');
 }
+
+// === Memory Extraction Functions ===
+
+export interface ChatMessageForExtraction {
+  role: string;
+  content: string;
+  timestamp?: string;
+}
+
+export interface ExtractedMemory {
+  category: 'user_preference' | 'user_fact' | 'agent_lesson' | 'agent_pattern' | 'task';
+  content: string;
+  tags: string[];
+  importance: number;
+  suggestedUri: string;
+  reasoning?: string;
+}
+
+export interface ExtractionResult {
+  memories: ExtractedMemory[];
+  summary: string;
+  tokensSaved?: number;
+  extractionTimeMs: number;
+}
+
+/**
+ * Extract memories from conversation session
+ */
+export async function extractSessionMemories(
+  messages: ChatMessageForExtraction[],
+  agentId: string
+): Promise<ExtractionResult> {
+  return invoke<ExtractionResult>('extract_session_memories', { messages, agentId });
+}
+
+/**
+ * Extract memories and store to SqliteStorage in one call
+ */
+export async function extractAndStoreMemories(
+  messages: ChatMessageForExtraction[],
+  agentId: string,
+  llmEndpoint?: string,
+  llmApiKey?: string
+): Promise<ExtractionResult> {
+  return invoke<ExtractionResult>('extract_and_store_memories', {
+    messages,
+    agentId,
+    llmEndpoint,
+    llmApiKey,
+  });
+}
+
+/**
+ * Inject relevant memories into prompt for enhanced context
+ */
+export async function injectVikingPrompt(
+  agentId: string,
+  basePrompt: string,
+  userInput: string,
+  maxTokens?: number
+): Promise<string> {
+  return invoke<string>('viking_inject_prompt', {
+    agentId,
+    basePrompt,
+    userInput,
+    maxTokens,
+  });
+}