@witty-ai/skill-insight 0.4.0-beta → 0.6.0-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@witty-ai/skill-insight",
-  "version": "0.4.0-beta",
+  "version": "0.6.0-beta",
   "description": "Agent Skill 评估与观测平台 — 量化评估 Skills 在 Agent 上的实际运行效果",
   "license": "MIT",
   "private": false,
@@ -21,12 +21,14 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "test": "node --import tsx --test \"test/**/*.test.ts\""
   },
   "dependencies": {
     "@prisma/client": "5.22.0",
     "@types/archiver": "^7.0.0",
     "@types/uuid": "^11.0.0",
+    "adm-zip": "^0.5.10",
     "archiver": "7.0.1",
     "chokidar": "^5.0.0",
     "dotenv": "^17.3.1",
@@ -49,12 +51,14 @@
     "xlsx": "^0.18.5"
   },
   "devDependencies": {
+    "@types/adm-zip": "^0.5.8",
     "@types/node": "^20",
     "@types/pg": "^8.18.0",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9",
     "eslint-config-next": "16.1.4",
+    "tsx": "^4.20.5",
     "typescript": "^5"
   }
 }

package/prisma/schema.prisma

@@ -34,6 +34,8 @@ model SkillVersion {
   id        String   @id @default(cuid())
   skillId   String
   version   Int
+  semanticVersion String?  // 语义化版本号，用于企业同步
+  enterpriseSkillId Int?  // 企业skill的id，用于删除同步
   content   String
   assetPath String?
   files     String?
@@ -68,6 +70,7 @@ model Execution {
   cacheReadInputTokens    Int?
   cacheCreationInputTokens Int?
   maxSingleCallTokens     Int?
+  reasoningTokens          Int?
   timestamp       DateTime @default(now())
   model           String?
   finalResult     String?

package/scripts/activate_telemetry.sh

@@ -30,14 +30,49 @@ fi
 # --- 2. Setup OpenCode Plugin (Priority) ---
 OPENCODE_PLUGIN_SRC="$SCRIPTS_DIR/opencode_plugin.ts"
 OPENCODE_PLUGIN_DEST="$HOME/.opencode/plugins/Witty-Skill-Insight.ts"
+OPENCODE_TUI_PLUGIN_SRC="$SCRIPTS_DIR/opencode_tui_plugin.tsx"
+OPENCODE_TUI_PLUGIN_DEST="$HOME/.opencode/plugins/Witty-Skill-Insight.tui.tsx"
+OPENCODE_CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/opencode"
+OPENCODE_CONFIG_PLUGIN_DIR="$OPENCODE_CONFIG_DIR/plugins"
 
 if [ -f "$OPENCODE_PLUGIN_SRC" ]; then
     echo "🛠️  Syncing OpenCode Plugin..."
     
     # Create plugin directory
     mkdir -p "$HOME/.opencode/plugins"
+    mkdir -p "$OPENCODE_CONFIG_PLUGIN_DIR"
     cp "$OPENCODE_PLUGIN_SRC" "$OPENCODE_PLUGIN_DEST"
+    cp "$OPENCODE_PLUGIN_SRC" "$OPENCODE_CONFIG_PLUGIN_DIR/Witty-Skill-Insight.ts"
     echo "✅ OpenCode Plugin installed to $OPENCODE_PLUGIN_DEST"
+    
+    if [ -f "$OPENCODE_TUI_PLUGIN_SRC" ]; then
+        cp "$OPENCODE_TUI_PLUGIN_SRC" "$OPENCODE_TUI_PLUGIN_DEST"
+        cp "$OPENCODE_TUI_PLUGIN_SRC" "$OPENCODE_CONFIG_PLUGIN_DIR/Witty-Skill-Insight.tui.tsx"
+        echo "✅ OpenCode TUI Plugin installed to $OPENCODE_TUI_PLUGIN_DEST"
+        if command -v node &> /dev/null; then
+            export TUI_PLUGIN_PATH="$OPENCODE_CONFIG_PLUGIN_DIR/Witty-Skill-Insight.tui.tsx"
+            export TUI_CONFIG_FILE="$OPENCODE_CONFIG_DIR/tui.json"
+            node - <<'NODE'
+const fs = require("fs");
+const path = require("path");
+const file = process.env.TUI_CONFIG_FILE;
+const pluginPath = process.env.TUI_PLUGIN_PATH;
+let data = {};
+try {
+  if (fs.existsSync(file)) {
+    const text = fs.readFileSync(file, "utf8");
+    data = text && text.trim() ? JSON.parse(text) : {};
+  }
+} catch {}
+if (!data || typeof data !== "object") data = {};
+const list = Array.isArray(data.plugin) ? data.plugin.slice() : [];
+if (pluginPath && !list.includes(pluginPath)) list.push(pluginPath);
+data.plugin = list;
+fs.mkdirSync(path.dirname(file), { recursive: true });
+fs.writeFileSync(file, JSON.stringify(data, null, 2));
+NODE
+        fi
+    fi
 
     # --- 2.1 Setup Skill-Insight Config (~/.skill-insight/.env) ---
     SKILL_INSIGHT_CONFIG_DIR="$HOME/.skill-insight"
@@ -46,10 +81,12 @@ if [ -f "$OPENCODE_PLUGIN_SRC" ]; then
 
     EXISTING_KEY=""
     EXISTING_HOST=""
+    EXISTING_SHOW_TASK_STATS=""
     if [ -f "$SKILL_INSIGHT_CONFIG_FILE" ]; then
         # match only UNCOMMENTED lines
         EXISTING_KEY=$(grep '^SKILL_INSIGHT_API_KEY=' "$SKILL_INSIGHT_CONFIG_FILE" | head -n 1 | cut -d'=' -f2-)
         EXISTING_HOST=$(grep '^SKILL_INSIGHT_HOST=' "$SKILL_INSIGHT_CONFIG_FILE" | head -n 1 | cut -d'=' -f2-)
+        EXISTING_SHOW_TASK_STATS=$(grep '^SKILL_INSIGHT_SHOW_TASK_STATS=' "$SKILL_INSIGHT_CONFIG_FILE" | head -n 1 | cut -d'=' -f2-)
     fi
 
     # API Key Selection Logic
@@ -89,13 +126,19 @@ if [ -f "$OPENCODE_PLUGIN_SRC" ]; then
     if [ -z "$API_KEY" ]; then
         echo "⚠️  Warning: No API Key provided. Data reporting will fail."
     fi
+    
+    FINAL_SHOW_TASK_STATS="$EXISTING_SHOW_TASK_STATS"
+    if [ -z "$FINAL_SHOW_TASK_STATS" ]; then
+        FINAL_SHOW_TASK_STATS="true"
+    fi
 
     echo "⚙️  Syncing configuration to $SKILL_INSIGHT_CONFIG_FILE..."
     touch "$SKILL_INSIGHT_CONFIG_FILE"
     cp "$SKILL_INSIGHT_CONFIG_FILE" "${SKILL_INSIGHT_CONFIG_FILE}.bak"
-    grep -v "^SKILL_INSIGHT_API_KEY=" "${SKILL_INSIGHT_CONFIG_FILE}.bak" | grep -v "^SKILL_INSIGHT_HOST=" > "$SKILL_INSIGHT_CONFIG_FILE"
+    grep -v "^SKILL_INSIGHT_API_KEY=" "${SKILL_INSIGHT_CONFIG_FILE}.bak" | grep -v "^SKILL_INSIGHT_HOST=" | grep -v "^SKILL_INSIGHT_SHOW_TASK_STATS=" > "$SKILL_INSIGHT_CONFIG_FILE"
     echo "SKILL_INSIGHT_API_KEY=$API_KEY" >> "$SKILL_INSIGHT_CONFIG_FILE"
     echo "SKILL_INSIGHT_HOST=$FINAL_HOST" >> "$SKILL_INSIGHT_CONFIG_FILE"
+    echo "SKILL_INSIGHT_SHOW_TASK_STATS=$FINAL_SHOW_TASK_STATS" >> "$SKILL_INSIGHT_CONFIG_FILE"
     rm "${SKILL_INSIGHT_CONFIG_FILE}.bak"
     echo "✅ Configuration updated (Other settings preserved)."
 

package/scripts/opencode_plugin.ts

@@ -18,9 +18,151 @@ function logDebug(msg) {
 
 // Global store
 let sessionStore = new Map();
-let uploadedSessions = new Set();
+let uploadedSessions = new Map(); // sessionId -> uploaded message count
 let sessionGraph = new Map(); // parent_id -> [child_ids]
 let pendingChildSessions = new Map(); // child_id -> {parent_id, data}
+let lastDeltaByPartField = new Map();
+
+const STORE_PATH = path.join(os.homedir(), '.opencode', 'witty_plugin_session_store.json');
+
+function cleanupOldSessions() {
+    const now = Date.now();
+    const threeDays = 3 * 24 * 3600 * 1000;
+    
+    let deletedCount = 0;
+    for (const [msgId, entry] of sessionStore.entries()) {
+        const time = entry.info?.created || entry.info?.time?.created;
+        if (time && (now - time > threeDays)) {
+            sessionStore.delete(msgId);
+            deletedCount++;
+        }
+    }
+    if (deletedCount > 0) logDebug(`Cleaned up ${deletedCount} old messages from sessionStore`);
+}
+
+function loadStore() {
+    try {
+        if (fs.existsSync(STORE_PATH)) {
+            const fileData = fs.readFileSync(STORE_PATH, 'utf8');
+            if (!fileData.trim()) return;
+            const data = JSON.parse(fileData);
+            
+            // Merge sessionStore: disk entries fill in gaps, but don't overwrite in-memory entries
+            if (data.sessionStore) {
+                const diskStore = new Map(data.sessionStore);
+                for (const [msgId, entry] of diskStore.entries()) {
+                    if (!sessionStore.has(msgId)) {
+                        if (entry.parts && !Array.isArray(entry.parts) && typeof entry.parts === 'object' && !(entry.parts instanceof Map)) {
+                             entry.parts = new Map(Object.entries(entry.parts));
+                        } else if (Array.isArray(entry.parts)) {
+                             entry.parts = new Map(entry.parts);
+                        } else if (!entry.parts) {
+                             entry.parts = new Map();
+                        }
+                        
+                        if (entry.toolParts && !Array.isArray(entry.toolParts) && typeof entry.toolParts === 'object' && !(entry.toolParts instanceof Map)) {
+                             entry.toolParts = new Map(Object.entries(entry.toolParts));
+                        } else if (Array.isArray(entry.toolParts)) {
+                             entry.toolParts = new Map(entry.toolParts);
+                        } else if (!entry.toolParts) {
+                             entry.toolParts = new Map();
+                        }
+
+                        sessionStore.set(msgId, entry);
+                    }
+                }
+            }
+            
+            // Merge uploadedSessions: keep the "newer" signature between memory and disk
+            if (data.uploadedSessions) {
+                for (const x of data.uploadedSessions) {
+                    const sid = Array.isArray(x) ? x[0] : x;
+                    const diskVal = Array.isArray(x) ? x[1] : 0;
+
+                    const normalize = (v) => {
+                        if (typeof v === 'number') return { count: v, lastAssistantLen: 0, lastTs: 0 };
+                        if (v && typeof v === 'object') {
+                            return {
+                                count: Number(v.count || 0),
+                                lastAssistantLen: Number(v.lastAssistantLen || 0),
+                                lastTs: Number(v.lastTs || 0)
+                            };
+                        }
+                        return { count: 0, lastAssistantLen: 0, lastTs: 0 };
+                    };
+
+                    const memSig = normalize(uploadedSessions.get(sid));
+                    const diskSig = normalize(diskVal);
+
+                    const diskNewer =
+                        diskSig.count > memSig.count ||
+                        (diskSig.count === memSig.count && diskSig.lastAssistantLen > memSig.lastAssistantLen) ||
+                        (diskSig.count === memSig.count && diskSig.lastAssistantLen === memSig.lastAssistantLen && diskSig.lastTs > memSig.lastTs);
+
+                    if (diskNewer) {
+                        uploadedSessions.set(sid, diskVal);
+                    } else if (!uploadedSessions.has(sid)) {
+                        uploadedSessions.set(sid, memSig);
+                    }
+                }
+            }
+            
+            // Merge sessionGraph: union child lists
+            if (data.sessionGraph) {
+                const diskGraph = new Map(data.sessionGraph);
+                for (const [parentId, childIds] of diskGraph.entries()) {
+                    if (!sessionGraph.has(parentId)) {
+                        sessionGraph.set(parentId, childIds);
+                    } else {
+                        const existing = sessionGraph.get(parentId);
+                        for (const cid of childIds) {
+                            if (!existing.includes(cid)) existing.push(cid);
+                        }
+                    }
+                }
+            }
+            
+            // Merge pendingChildSessions
+            if (data.pendingChildSessions) {
+                const diskPending = new Map(data.pendingChildSessions);
+                for (const [childId, childData] of diskPending.entries()) {
+                    if (!pendingChildSessions.has(childId)) {
+                        pendingChildSessions.set(childId, childData);
+                    }
+                }
+            }
+            
+            logDebug(`Loaded store (merged): ${sessionStore.size} messages`);
+        }
+    } catch(e) {
+        logDebug("Store read err: " + e.message);
+    }
+}
+
+function saveStore() {
+    try {
+        cleanupOldSessions();
+        
+        // Merge with disk state to prevent concurrent process data loss.
+        // loadStore() uses merge semantics (won't overwrite in-memory entries).
+        loadStore();
+        
+        const data = {
+            sessionStore: Array.from(sessionStore.entries()).map(([k, v]) => [k, {
+                ...v,
+                parts: v.parts instanceof Map ? Array.from(v.parts.entries()) : (v.parts || []),
+                toolParts: v.toolParts instanceof Map ? Array.from(v.toolParts.entries()) : (v.toolParts || [])
+            }]),
+            uploadedSessions: Array.from(uploadedSessions.entries()),
+            sessionGraph: Array.from(sessionGraph.entries()),
+            pendingChildSessions: Array.from(pendingChildSessions.entries()),
+            timestamp: new Date().toISOString()
+        };
+        fs.writeFileSync(STORE_PATH, JSON.stringify(data, null, 2), 'utf8');
+    } catch(e) {
+        logDebug("Store sync err: " + e.message);
+    }
+}
 
 function toMsTimestamp(v) {
     if (v == null) return null;
@@ -120,11 +262,12 @@ function loadConfiguration() {
 
 function collectSessionMessages(sessionId) {
     const messages = [];
+    logDebug(`collectSessionMessages: scanning ${sessionStore.size} entries for session ${sessionId}`);
     for (const [mid, entry] of sessionStore.entries()) {
         if (entry.info.sessionID === sessionId) {
             // Calculate latency for this message if possible from parts
             let partBasedDuration = 0;
-            if (entry.parts.size > 0) {
+            if (entry.parts instanceof Map && entry.parts.size > 0) {
                 const parts = Array.from(entry.parts.values()).map(p => p.time?.start || 0).filter(t => t > 0).sort((a,b)=>a-b);
                 if (parts.length >= 1) {
                     const start = parts[0];
@@ -133,9 +276,13 @@ function collectSessionMessages(sessionId) {
                 }
             }
 
+            const role = entry.info.role || 'unknown';
+            const content = entry.content || entry.info.content || "";
+            logDebug(`Found message in store: id=${mid}, role=${role}, content_len=${content.length}`);
+
             messages.push({
-                role: entry.info.role || 'unknown',
-                content: entry.content || entry.info.content || "",
+                role: role,
+                content: content,
                 tool_calls: entry.info.tool_calls || entry.info.toolCalls,
                 function_call: entry.info.function_call || entry.info.functionCall,
                 usage: entry.info.usage || entry.info.tokens,
@@ -147,6 +294,7 @@ function collectSessionMessages(sessionId) {
             });
         }
     }
+    logDebug(`collectSessionMessages: collected ${messages.length} messages for ${sessionId}`);
     return messages;
 }
 
@@ -196,6 +344,7 @@ function collectSessionWithChildren(sessionId) {
 }
 
 export default async function WittySkillInsightPlugin(input) {
+  loadStore();
   const { apiKey, host } = loadConfiguration();
   if (!apiKey || !host) {
       logDebug("Plugin disabled: Missing API Key or Host");
@@ -250,26 +399,10 @@ export default async function WittySkillInsightPlugin(input) {
 
       // logDebug(`Event: ${event.type}`);
 
-       try {
+      try {
            // Attempt to find session ID in various places
-           const sessionId = event.session_id || event.properties?.sessionID || event.payload?.session_id;
-
-           // 0. Handle session.created events to establish parent-child relationships
-           if (event.type === 'session.created') {
-               const sessionInfo = event.properties?.info || event.payload?.info;
-               if (sessionInfo && sessionInfo.id && sessionInfo.parentID) {
-                   const childId = sessionInfo.id;
-                   const parentId = sessionInfo.parentID;
-                   
-                   if (!sessionGraph.has(parentId)) {
-                       sessionGraph.set(parentId, []);
-                   }
-                   if (!sessionGraph.get(parentId).includes(childId)) {
-                       sessionGraph.get(parentId).push(childId);
-                       logDebug(`Session created: ${childId} is child of ${parentId}`);
-                   }
-               }
-           }
+           let sessionId = event.session_id || event.properties?.sessionID || event.payload?.session_id;
+           let eagerFlush = false;
 
            // 1. Accumulate Message Metadata
            if (event.type === 'message.created' || event.type === 'message.updated') {
@@ -284,11 +417,16 @@ export default async function WittySkillInsightPlugin(input) {
                      });
                  }
                  const entry = sessionStore.get(msgId);
+                 if (!sessionId) sessionId = info.sessionID || info.sessionId || entry.info?.sessionID;
                  if (sessionId) entry.info.sessionID = sessionId;
                   // Merge info
                   Object.assign(entry.info, info);
                   if (info.tool_calls || info.toolCalls) entry.info.tool_calls = info.tool_calls || info.toolCalls;
                   if (info.function_call || info.functionCall) entry.info.function_call = info.function_call || info.functionCall;
+
+                  if (entry.info?.role === 'assistant' && (entry.info.finish || entry.info.time?.completed != null)) {
+                      eagerFlush = true;
+                  }
              }
           }
 
@@ -309,6 +447,9 @@ export default async function WittySkillInsightPlugin(input) {
                         });
                   }
                   const entry = sessionStore.get(msgId);
+                  if (!sessionId) sessionId = entry.info?.sessionID || part.sessionID || part.session_id;
+                  if (!(entry.parts instanceof Map)) entry.parts = new Map(Array.isArray(entry.parts) ? entry.parts : []);
+                  if (entry.toolParts && !(entry.toolParts instanceof Map)) entry.toolParts = new Map(Array.isArray(entry.toolParts) ? entry.toolParts : []);
                   
                   // Store part
                   const partId = part.id || `temp_${Date.now()}_${Math.random()}`;
@@ -414,22 +555,82 @@ export default async function WittySkillInsightPlugin(input) {
               }
           }
 
+          if (event.type === 'message.part.delta') {
+              const props = event.properties || event.payload || {};
+              const msgId = props.messageID || props.message_id;
+              const partId = props.partID || props.part_id;
+              const field = props.field;
+              const delta = props.delta;
+
+              if (msgId && partId && field && typeof delta === 'string') {
+                  if (!sessionStore.has(msgId)) {
+                      sessionStore.set(msgId, {
+                          info: { sessionID: sessionId },
+                          parts: new Map(),
+                          toolParts: new Map(),
+                          content: ''
+                      });
+                  }
+
+                  const entry = sessionStore.get(msgId);
+                  if (!sessionId) sessionId = entry.info?.sessionID;
+                  if (!(entry.parts instanceof Map)) entry.parts = new Map(Array.isArray(entry.parts) ? entry.parts : []);
+
+                  const dedupeKey = `${msgId}:${partId}:${field}`;
+                  const lastDelta = lastDeltaByPartField.get(dedupeKey);
+                  if (lastDelta !== delta) {
+                      lastDeltaByPartField.set(dedupeKey, delta);
+                      if (lastDeltaByPartField.size > 5000) {
+                          for (const k of lastDeltaByPartField.keys()) {
+                              lastDeltaByPartField.delete(k);
+                              if (lastDeltaByPartField.size <= 4000) break;
+                          }
+                      }
+
+                      const existingPart = entry.parts.get(partId) || {
+                          id: partId,
+                          messageID: msgId,
+                          sessionID: sessionId,
+                          type: 'text'
+                      };
+                      const prev = typeof existingPart[field] === 'string' ? existingPart[field] : '';
+                      existingPart[field] = prev + delta;
+                      entry.parts.set(partId, existingPart);
+
+                      let full = "";
+                      const sortedParts = Array.from(entry.parts.values()).sort((a, b) => {
+                          const ta = a.time?.start || (a.meta && a.meta.start) || 0;
+                          const tb = b.time?.start || (b.meta && b.meta.start) || 0;
+                          return ta - tb;
+                      });
+
+                      for (const p of sortedParts) {
+                          if (p.text) full += p.text;
+                          else if (p.content) full += p.content;
+                      }
+                      entry.content = full;
+                  }
+              }
+          }
+
            // 3. Upload on Session Idle
-           if (event.type === "session.idle") {
+           if (event.type === "session.idle" || eagerFlush) {
                if (!sessionId || !sessionId.startsWith("ses")) return;
 
-               // Check if this is a child session (has parent_id or is in sessionGraph)
-               const parentId = event.parent_id || event.properties?.parentID || event.payload?.parent_id;
-               
-               // Also check if this session is registered as a child in sessionGraph
-               let foundParentId = parentId;
-               if (!foundParentId) {
-                   for (const [potentialParent, childIds] of sessionGraph.entries()) {
-                       if (childIds.includes(sessionId)) {
-                           foundParentId = potentialParent;
-                           logDebug(`Found parent ${foundParentId} for for child ${sessionId} from sessionGraph`);
-                           break;
-                       }
+               // Reload store from disk to pick up any data written by
+               // concurrent child processes (e.g. opencode run executed
+               // from within the opencode interactive interface).
+               loadStore();
+
+               // Only treat a session as "child" when it was detected via Task tool
+               // (i.e. registered in sessionGraph). Do NOT rely on event.parentID because
+               // nested `opencode run ...` can also set parentID and we want both sessions uploaded.
+               let foundParentId = null;
+               for (const [potentialParent, childIds] of sessionGraph.entries()) {
+                   if (childIds.includes(sessionId)) {
+                       foundParentId = potentialParent;
+                       logDebug(`Found parent ${foundParentId} for for child ${sessionId} from sessionGraph`);
+                       break;
                    }
                }
                
@@ -495,6 +696,7 @@ export default async function WittySkillInsightPlugin(input) {
               let totalOutputTokens = 0;
               let totalCacheReadInputTokens = 0;
               let totalCacheCreationInputTokens = 0;
+              let totalReasoningTokens = 0;
               let llmCallCount = 0;
               let toolCallCount = 0;
               let toolCallErrorCount = 0;
@@ -524,11 +726,18 @@ export default async function WittySkillInsightPlugin(input) {
                           const cacheReadToks = Number(u.cache?.read || u.cache_read_input_tokens || 0);
                           const cacheCreateToks = Number(u.cache?.write || u.cache_creation_input_tokens || 0);
                           const inputToks = Number(u.input_tokens || u.input || 0);  // base input only (excludes cache)
-                          const outputToks = Number(u.output_tokens || u.output || 0);
+                          const rawOutputToks = Number(u.output_tokens || u.output || 0);
+                          const reasoningToks = Number(u.reasoning || u.reasoning_tokens || u.completion_tokens_details?.reasoning_tokens || 0);
+                          // OpenCode reports reasoning separately from output; DeepSeek API includes it in output.
+                          // Normalize: output_tokens should always include reasoning tokens.
+                          const outputToks = (u.reasoning !== undefined && reasoningToks > 0 && rawOutputToks < reasoningToks)
+                              ? rawOutputToks + reasoningToks
+                              : rawOutputToks;
                           totalInputTokens += inputToks;
                           totalOutputTokens += outputToks;
                           totalCacheReadInputTokens += cacheReadToks;
                           totalCacheCreationInputTokens += cacheCreateToks;
+                          totalReasoningTokens += reasoningToks;
                           const callTotal = inputToks + cacheReadToks + cacheCreateToks + outputToks;
                           if (callTotal > maxSingleCallTokens) maxSingleCallTokens = callTotal;
                       }
@@ -574,6 +783,7 @@ export default async function WittySkillInsightPlugin(input) {
                   cache_read_input_tokens: totalCacheReadInputTokens,
                   cache_creation_input_tokens: totalCacheCreationInputTokens,
                   max_single_call_tokens: maxSingleCallTokens,
+                  reasoning_tokens: totalReasoningTokens,
                   final_result: lastAssistantContent,
                   interactions: messages.map(m => ({
                       role: m.role,
@@ -587,11 +797,38 @@ export default async function WittySkillInsightPlugin(input) {
                   timestamp: new Date().toISOString()
               };
 
-              if (uploadedSessions.has(sessionId)) {
-                  logDebug(`Session ${sessionId} already uploaded, skipping.`);
+              let lastTs = 0;
+              for (const m of messages) {
+                  const t1 = toMsTimestamp(m.timestamp) || 0;
+                  const t2 = toMsTimestamp(m.timeInfo?.completed) || 0;
+                  const t3 = toMsTimestamp(m.timeInfo?.created) || 0;
+                  lastTs = Math.max(lastTs, t1, t2, t3);
+              }
+              const lastAssistantLen = (lastAssistantContent || '').length;
+
+              const normalize = (v) => {
+                  if (typeof v === 'number') return { count: v, lastAssistantLen: 0, lastTs: 0 };
+                  if (v && typeof v === 'object') {
+                      return {
+                          count: Number(v.count || 0),
+                          lastAssistantLen: Number(v.lastAssistantLen || 0),
+                          lastTs: Number(v.lastTs || 0)
+                      };
+                  }
+                  return { count: 0, lastAssistantLen: 0, lastTs: 0 };
+              };
+
+              const prevSig = normalize(uploadedSessions.get(sessionId));
+              const shouldSkip =
+                  messages.length <= prevSig.count &&
+                  lastAssistantLen <= prevSig.lastAssistantLen &&
+                  lastTs <= prevSig.lastTs;
+
+              if (shouldSkip) {
+                  logDebug(`Session ${sessionId} already uploaded (count=${prevSig.count}, lastAssistantLen=${prevSig.lastAssistantLen}, lastTs=${prevSig.lastTs}) (cur: count=${messages.length}, lastAssistantLen=${lastAssistantLen}, lastTs=${lastTs}), skipping.`);
                   return;
               }
-              uploadedSessions.add(sessionId);
+              uploadedSessions.set(sessionId, { count: messages.length, lastAssistantLen, lastTs });
 
               const body = JSON.stringify(payload);
               logDebug(`Payload Body Size: ${Buffer.byteLength(body)} bytes`);
@@ -691,6 +928,8 @@ try {
           }
       } catch (err) {
           logDebug(`Plugin Exception: ${err.message}`);
+      } finally {
+        saveStore();
       }
     }
   };