@qiaolei81/copilot-session-viewer 0.2.7 → 0.3.1

package/CHANGELOG.md

@@ -5,6 +5,59 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.1] - 2026-03-07
+
+### Fixed
+- **Session Deduplication** - VSCode sessions with the same ID across multiple workspaces are now deduplicated (keeps most recently updated)
+- **WIP Status Accuracy** - VSCode agentic sessions now also check file mtime for WIP detection; threshold increased from 5 to 15 minutes
+- **Timeline Bar Positioning** - UserReq rows with 0 tools no longer render at the start of the timeline
+- **Tag Isolation** - Tags now use filePath-based storage to prevent shared directory collisions (Claude, Pi-Mono, Copilot CLI)
+- **Per-Session Insight Files** - Agent review files use `{sessionId}.agent-review.md` naming to avoid collisions
+- **Export All Sources** - Session export works for all sources including VSCode; file-based exports include `.tags.json`
+- **Inline References in Markdown** - VSCode `inlineReference` items (file/folder links) now rendered as code references instead of being silently dropped, fixing broken markdown tables
+
+### Performance
+- **60s Cache + Request Dedup** - `SessionRepository.findAll()` results cached for 60 seconds with concurrent request deduplication, reducing TTFB from ~11s to <100ms on cache hit
+
+## [0.3.0] - 2026-03-07
+
+### Added
+- **VSCode Copilot Chat Support** - Full support for VSCode Copilot Chat sessions as a new source (`vscode`)
+  - Session cards show model badge + repo basename
+  - Copilot Chat extension version badge
+  - WIP badge for active sessions
+  - SubAgent name badges on assistant messages (replaces generic ASSISTANT badge)
+  - UserReq rows in Gantt timeline
+  - Turn divider shows start time + duration
+- **Dynamic Source Path Hints** - Clicking filter pills shows the source directory path (cross-platform)
+- **Multi-Tool Branding** - Homepage wording updated to reflect multi-tool support (Copilot CLI, Claude Code, Pi-Mono, Copilot Chat)
+
+### Changed
+- **Source Display Names** - `copilot` → "Copilot CLI", `vscode` → "Copilot Chat"
+- **Session Info Layout** - Shows Model + Repo basename instead of CWD hash path
+- **Tool Input Display** - URI objects simplified to filename only; edits collapsed to count
+- **Tool Call Width** - Truncation increased to 200 chars with flex-wrap
+- **SubAgent Badge** - Shows name only (no emoji prefix)
+- **System Messages** - System-sourced `user.message` converted to `system.notification` type with SYSTEM badge
+
+### Fixed
+- Claude `tool_result` user messages filtered from display
+- VSCode parser: `resultDetails` iteration crash, request timestamps for subagent events
+- VSCode subagent dedup by `subAgentId` instead of name
+- VSCode `findById` uses `selectedModel` + `resolveWorkspacePath`
+- VSCode duration estimation fix
+- Session detail repo dedup, skill table width
+- SESSION INFO duplicate Model/label
+- SubAgent badge uses `agentName` from `toolSpecificData`
+- Source path hints from server (cross-platform Windows/macOS/Linux)
+
+## [0.2.7] - 2026-03-05
+
+### Added
+- **Session Tagging** - Add, remove, and filter sessions by custom tags from the session list and detail pages
+- **Unit Tests for Tagging** - 70 new tests covering `tagService` and `tagController` (608 total)
+- **E2E Tests for Tagging** - Playwright tests covering tagging API and UI flows
+
 ## [0.2.6] - 2026-03-05
 
 ### Fixed

package/README.md

@@ -6,9 +6,9 @@
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org/)
 
 **Multi-Tool Session Log Viewer & Analyzer**  
-View and analyze AI coding assistant sessions from **GitHub Copilot CLI**, **Claude Code CLI**, and **Pi-Mono** with time analysis, virtual scrolling, and AI-powered insights.
+View and analyze AI coding assistant sessions from **GitHub Copilot CLI**, **Copilot Chat (VSCode)**, **Claude Code CLI**, and **Pi-Mono** with time analysis, virtual scrolling, and AI-powered insights.
 
-A modern web-based viewer for analyzing AI coding assistant session logs with virtual scrolling, infinite loading, time analysis, and AI-powered insights. Supports **GitHub Copilot CLI**, **Claude Code CLI**, and **Pi-Mono** sessions.
+A modern web-based viewer for analyzing AI coding assistant session logs with virtual scrolling, infinite loading, time analysis, and AI-powered insights. Supports **GitHub Copilot CLI**, **Copilot Chat (VSCode)**, **Claude Code CLI**, and **Pi-Mono** sessions.
 
 ### Session List
 ![Session List](https://raw.githubusercontent.com/qiaolei81/copilot-session-viewer/main/docs/images/homepage.png)
@@ -57,7 +57,7 @@ copilot-session-viewer
 - **🚀 Virtual Scrolling** - Handle 1000+ events smoothly
 - **♾️ Infinite Scroll** - Progressive session loading for better performance
 - **🤖 AI Insights** - LLM-powered session analysis
-- **🎭 Multi-Format Support** - Copilot, Claude Code, and Pi-Mono sessions
+- **🎭 Multi-Format Support** - Copilot CLI, Copilot Chat (VSCode), Claude Code, and Pi-Mono sessions
 
 ### 🎨 **User Experience**
 - **🌙 Dark Theme** - GitHub-inspired interface
@@ -69,7 +69,7 @@ copilot-session-viewer
 - **Vue 3** - Reactive virtual scrolling
 - **Express.js** - Robust backend API
 - **ZIP Import/Export** - Session sharing capabilities with security validation
-- **Multi-Source Support** - Copilot (`~/.copilot/session-state/`), Claude (`~/.claude/projects/`), Pi-Mono (`~/.pi/agent/sessions/`)
+- **Multi-Source Support** - Copilot CLI (`~/.copilot/session-state/`), Copilot Chat (`~/Library/Application Support/Code/User/workspaceStorage/`), Claude (`~/.claude/projects/`), Pi-Mono (`~/.pi/agent/sessions/`)
 - **Unified Event Format** - Consistent schema across all sources
 - **Memory Pagination** - Efficient handling of large sessions
 - **XSS Protection** - DOMPurify-based HTML sanitization
@@ -81,7 +81,8 @@ copilot-session-viewer
 
 1. **Generate Sessions** - Use GitHub Copilot CLI, Claude Code CLI, or Pi-Mono to create session logs
 2. **Auto-Discovery** - Sessions are automatically detected from:
-   - Copilot: `~/.copilot/session-state/`
+   - Copilot CLI: `~/.copilot/session-state/`
+   - Copilot Chat: `~/Library/Application Support/Code/User/workspaceStorage/`
    - Claude: `~/.claude/projects/`
    - Pi-Mono: `~/.pi/agent/sessions/`
 3. **Browse & Analyze** - View sessions with infinite scroll and detailed event streams
@@ -124,8 +125,8 @@ This project includes comprehensive unit and E2E test coverage with CI/CD integr
 
 ### Test Coverage
 
-- **470+ Tests** (411 unit + 59 E2E)
-- **Unified Format Tests** - Mock data validation for all sources (Copilot, Claude, Pi-Mono)
+- **700+ Tests** (622 unit + 80 E2E)
+- **Unified Format Tests** - Mock data validation for all sources (Copilot CLI, Copilot Chat, Claude, Pi-Mono)
 - **Security Tests** - XSS prevention, ZIP bomb defense
 - **Integration Tests** - Session import/export, file operations
 - **CI-Friendly** - Mock data generation for reproducible tests
@@ -153,15 +154,15 @@ npm run test:all
 
 GitHub Actions workflow includes:
 1. **Linting** - ESLint code quality checks
-2. **Unit Tests** - 411 Jest tests with coverage
+2. **Unit Tests** - 622 Jest tests with coverage
 3. **Mock Data Generation** - Reproducible test session fixtures
-4. **E2E Tests** - 59 Playwright tests with Chromium
+4. **E2E Tests** - 80 Playwright tests with Chromium
 5. **Artifact Upload** - Test results on failure
 
 **Test Data Strategy:**
 - ✅ CI uses generated mock data (fast, reliable, no external dependencies)
 - ✅ Local development can use real sessions for integration testing
-- ✅ Fixtures cover all event formats (Copilot, Claude, Pi-Mono)
+- ✅ Fixtures cover all event formats (Copilot CLI, Copilot Chat, Claude, Pi-Mono)
 
 ---
 
@@ -187,9 +188,10 @@ GitHub Actions workflow includes:
                       ↕ File System
 ┌─────────────────────────────────────────────────┐
 │  Data Layer (Multi-Source)                      │
-│  • Copilot: ~/.copilot/session-state/           │
-│  • Claude:  ~/.claude/projects/                 │
-│  • Pi-Mono: ~/.pi/agent/sessions/               │
+│  • Copilot CLI: ~/.copilot/session-state/        │
+│  • Copilot Chat: ~/Library/.../workspaceStorage/ │
+│  • Claude:  ~/.claude/projects/                  │
+│  • Pi-Mono: ~/.pi/agent/sessions/                │
 └─────────────────────────────────────────────────┘
 ```
 
@@ -304,12 +306,13 @@ MIT License - see [LICENSE](LICENSE) file for details
 - [DOMPurify](https://github.com/cure53/DOMPurify) - XSS protection
 - [Playwright](https://playwright.dev/) - E2E testing
 
-**Recent Updates (v0.1.9+):**
-- ✨ Multi-source support (Copilot, Claude, Pi-Mono)
+**Recent Updates (v0.3.0):**
+- ✨ VSCode Copilot Chat support (4th source)
+- 🏷️ Session tagging system
+- 🔄 Multi-tool branding (Copilot CLI, Copilot Chat, Claude Code, Pi-Mono)
 - 🔒 XSS protection with DOMPurify
 - 🛡️ ZIP bomb defense (4-layer validation)
-- 📄 Memory pagination API
-- 🧪 470+ tests with CI/CD integration
+- 🧪 700+ tests with CI/CD integration
 - 📚 Comprehensive documentation
 
 ---

package/lib/parsers/index.js

@@ -2,7 +2,7 @@ const BaseSessionParser = require('./base-parser');
 const CopilotSessionParser = require('./copilot-parser');
 const ClaudeSessionParser = require('./claude-parser');
 const PiMonoParser = require('./pi-mono-parser');
-// const VsCodeParser = require('./vscode-parser'); // TODO: VSCode parser disabled
+const VsCodeParser = require('./vscode-parser');
 const ParserFactory = require('./parser-factory');
 
 module.exports = {
@@ -10,6 +10,6 @@ module.exports = {
   CopilotSessionParser,
   ClaudeSessionParser,
   PiMonoParser,
-  // VsCodeParser, // TODO: VSCode parser disabled
+  VsCodeParser,
   ParserFactory
 };

package/lib/parsers/vscode-parser.js

@@ -11,14 +11,26 @@ const BaseSessionParser = require('./base-parser');
  */
 class VsCodeParser extends BaseSessionParser {
   /**
-   * VSCode sessions are passed as a plain JS object (already parsed JSON),
-   * not as an array of events. We detect them by the presence of `requests`.
-   * The ParserFactory passes raw events arrays for JSONL sources, so we
-   * keep canParse() returning false — VSCode sessions are loaded differently.
+   * VSCode sessions can be either:
+   * 1. Old format: Plain JSON object with `requests` array
+   * 2. New format: JSONL with ObjectMutationLog entries (kind: 0|1|2|3)
+   *
+   * For JSONL format, the first line has kind=0 with v.sessionId
    */
-  canParse(_events) {
-    // VSCode sessions are JSON objects, not event arrays.
-    // SessionRepository calls parseVsCode() directly; canParse is unused here.
+  canParse(lines) {
+    if (!Array.isArray(lines) || lines.length === 0) return false;
+
+    // Check if this is JSONL format (array of parsed lines)
+    const firstLine = lines[0];
+
+    // New JSONL format: first line has kind=0 and v.sessionId
+    if (firstLine && typeof firstLine === 'object' &&
+        firstLine.kind === 0 &&
+        firstLine.v &&
+        firstLine.v.sessionId) {
+      return true;
+    }
+
     return false;
   }
 
@@ -38,11 +50,172 @@ class VsCodeParser extends BaseSessionParser {
     };
   }
 
-  // ---- required abstract methods (not used for VsCode path) ----
-  parse(_events) { return null; }
-  getMetadata(_events) { return null; }
-  extractTurns(_events) { return []; }
-  extractToolCalls(_events) { return []; }
+  /**
+   * Parse JSONL format (ObjectMutationLog) - new VS Code format
+   * @param {Array} lines - Array of parsed JSON objects from JSONL file
+   * @returns {Object} Normalised session data
+   */
+  parseJsonl(lines) {
+    // Replay mutations to reconstruct the session state
+    const sessionState = this.replayMutations(lines);
+
+    // Use existing methods to convert to events
+    const metadata = this._getMetadata(sessionState);
+    const events = this._toEvents(sessionState);
+
+    return {
+      metadata,
+      turns: this._extractTurns(events),
+      toolCalls: this._extractToolCalls(events),
+      allEvents: events,
+    };
+  }
+
+  /**
+   * Replay ObjectMutationLog entries to reconstruct session state
+   * @param {Array} lines - Array of mutation entries { kind, k, v, i }
+   * @returns {Object} Reconstructed session state
+   */
+  replayMutations(lines) {
+    let state = null;
+
+    for (const entry of lines) {
+      if (!entry || typeof entry !== 'object') continue;
+
+      const { kind, k, v, i } = entry;
+
+      switch (kind) {
+        case 0: // Initial - set entire state
+          state = v;
+          break;
+
+        case 1: // Set - update property at path
+          if (k && Array.isArray(k)) {
+            this._applySet(state, k, v);
+          }
+          break;
+
+        case 2: // Push - append to array (with optional truncate)
+          if (k && Array.isArray(k)) {
+            this._applyPush(state, k, v, i);
+          }
+          break;
+
+        case 3: // Delete - remove property at path
+          if (k && Array.isArray(k)) {
+            this._applyDelete(state, k);
+          }
+          break;
+
+        default:
+          console.warn(`[VsCodeParser] Unknown mutation kind: ${kind}`);
+      }
+    }
+
+    return state;
+  }
+
+  /**
+   * Apply Set mutation: set value at path k in state
+   * @private
+   */
+  _applySet(state, path, value) {
+    if (!state || path.length === 0) return;
+
+    let current = state;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!current[key]) {
+        // Create intermediate object or array based on next key type
+        current[key] = typeof path[i + 1] === 'number' ? [] : {};
+      }
+      current = current[key];
+    }
+
+    const lastKey = path[path.length - 1];
+    current[lastKey] = value;
+  }
+
+  /**
+   * Apply Push mutation: append items to array at path k
+   * If i is set, truncate array to index i first
+   * @private
+   */
+  _applyPush(state, path, values, startIndex) {
+    if (!state || path.length === 0) return;
+
+    let current = state;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!current[key]) {
+        current[key] = typeof path[i + 1] === 'number' ? [] : {};
+      }
+      current = current[key];
+    }
+
+    const lastKey = path[path.length - 1];
+    if (!current[lastKey]) {
+      current[lastKey] = [];
+    }
+
+    const arr = current[lastKey];
+    if (!Array.isArray(arr)) {
+      console.warn(`[VsCodeParser] Push target is not an array: ${path.join('.')}`);
+      return;
+    }
+
+    // Truncate if startIndex is specified
+    if (startIndex !== undefined && startIndex !== null) {
+      arr.length = startIndex;
+    }
+
+    // Append new values
+    if (values && Array.isArray(values) && values.length > 0) {
+      arr.push(...values);
+    }
+  }
+
+  /**
+   * Apply Delete mutation: remove property at path k
+   * @private
+   */
+  _applyDelete(state, path) {
+    if (!state || path.length === 0) return;
+
+    let current = state;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!current[key]) return; // Path doesn't exist
+      current = current[key];
+    }
+
+    const lastKey = path[path.length - 1];
+    delete current[lastKey];
+  }
+
+  // ---- required abstract methods (for ParserFactory interface) ----
+  parse(events) {
+    // For JSONL format, use parseJsonl
+    if (Array.isArray(events) && events.length > 0 && this.canParse(events)) {
+      return this.parseJsonl(events);
+    }
+    return null;
+  }
+
+  getMetadata(events) {
+    const parsed = this.parse(events);
+    return parsed ? parsed.metadata : null;
+  }
+
+  extractTurns(events) {
+    const parsed = this.parse(events);
+    return parsed ? parsed.turns : [];
+  }
+
+  extractToolCalls(events) {
+    const parsed = this.parse(events);
+    return parsed ? parsed.toolCalls : [];
+  }
 
   // ---- private helpers ----
 
@@ -98,42 +271,16 @@ class VsCodeParser extends BaseSessionParser {
       const completedAt = req.modelState?.completedAt
         ? new Date(req.modelState.completedAt).toISOString()
         : ts;
-      const reqStartMs = ts ? new Date(ts).getTime() : null;
-      const reqEndMs = completedAt ? new Date(completedAt).getTime() : reqStartMs;
-      const reqDurationMs = (reqStartMs && reqEndMs) ? (reqEndMs - reqStartMs) : 0;
+
 
       // Build subAgentInvocationId → agent name map from this request's response items
-      const responseItems = req.response || [];
+      const responseItems = Array.isArray(req.response) ? req.response : [];
       const subAgentNames = this._buildSubAgentNameMap(responseItems);
 
-      // Count items per subagent (in first-appearance order) for proportional time estimation
-      const subAgentItemCounts = new Map(); // sid → count
-      const subAgentOrder = []; // ordered unique sids
-      for (const item of responseItems) {
-        if (!item || typeof item !== 'object') continue;
-        const sid = item.subAgentInvocationId;
-        if (!sid) continue;
-        if (!subAgentItemCounts.has(sid)) { subAgentItemCounts.set(sid, 0); subAgentOrder.push(sid); }
-        subAgentItemCounts.set(sid, subAgentItemCounts.get(sid) + 1);
-      }
-      const totalSubAgentItems = [...subAgentItemCounts.values()].reduce((a, b) => a + b, 0);
-
-      // Compute estimated start/end timestamps per subagent (proportional to item count)
-      const subAgentTimestamps = new Map(); // sid → { startTime, endTime }
-      if (reqStartMs && totalSubAgentItems > 0) {
-        let cursor = reqStartMs;
-        for (const sid of subAgentOrder) {
-          const fraction = subAgentItemCounts.get(sid) / totalSubAgentItems;
-          const duration = Math.round(reqDurationMs * fraction);
-          subAgentTimestamps.set(sid, {
-            startTime: new Date(cursor).toISOString(),
-            endTime: new Date(cursor + duration).toISOString(),
-          });
-          cursor += duration;
-        }
-      }
-
-      const seenSubAgents = new Set();
+      // Note: VS Code JSONL does not record per-subagent timestamps.
+      // All subagents in a request span the same wall-clock window (they run in parallel).
+      // Use request start as START and request completedAt as COMPLETE for all subagents,
+      // which is accurate for parallel dispatch and avoids interleaved/crossed timelines.
 
       // user.message
       const userText = this._extractUserText(req.message);
@@ -165,7 +312,7 @@ class VsCodeParser extends BaseSessionParser {
         assistantText = '';
         if (!trimmed) return;
         const sid = currentSubAgentId;
-        const _agentName = sid ? (subAgentNames[sid] || sid.slice(0, 8)) : null;
+        const agentName = sid ? (subAgentNames[sid] || sid.slice(0, 8)) : null;
         events.push({
           type: 'assistant.message',
           id: `${req.requestId}-text-${itemIndex}`,
@@ -175,32 +322,9 @@ class VsCodeParser extends BaseSessionParser {
             message: trimmed,
             content: trimmed,
             tools: [],
-            subAgentId: null,
-            subAgentName: null,
-            parentToolCallId: null,
-          },
-        });
-      };
-
-      const emitSubAgentStart = (sid, _itemIdx) => {
-        if (!sid || seenSubAgents.has(sid)) return;
-        seenSubAgents.add(sid);
-        const agentName = subAgentNames[sid] || `subagent-${sid.slice(0, 8)}`;
-        const times = subAgentTimestamps.get(sid);
-        const startTs = times?.startTime || completedAt;
-        events.push({
-          type: 'subagent.started',
-          id: `${req.requestId}-subagent-${sid}`,
-          timestamp: startTs,
-          parentId: req.requestId,
-          data: {
-            subAgentId: sid,
+            subAgentId: sid || null,
             subAgentName: agentName,
-            agentName: agentName,
-            agentDisplayName: agentName,
-            toolCallId: sid,
-            badgeLabel: agentName,
-            badgeClass: 'badge-subagent',
+            parentToolCallId: null,
           },
         });
       };
@@ -224,15 +348,28 @@ class VsCodeParser extends BaseSessionParser {
           case null: {
             // Plain markdown text item (no kind field, has 'value')
             const text = item.value || '';
-            if (text) assistantText += text + '\n';
+            if (text) assistantText += text;
+            break;
+          }
+
+          case 'inlineReference': {
+            // File/folder reference inline in markdown — append name as code reference
+            const name = item.name || '';
+            if (name) assistantText += '`' + name + '`';
             break;
           }
 
           case 'toolInvocationSerialized': {
             flushText();
-            // Emit subagent.start on first appearance of this subagent
-            const sid = item.subAgentInvocationId;
-            emitSubAgentStart(sid, itemIndex);
+            // runSubagent items: toolId='runSubagent', toolCallId=subagent-id, subAgentInvocationId=null
+            // Regular tool items: toolId=e.g. 'copilot_readFile', subAgentInvocationId=owning-subagent-id
+            const sid = item.toolId === 'runSubagent'
+              ? item.toolCallId   // the subagent being launched
+              : item.subAgentInvocationId; // the subagent that launched this tool
+            if (item.toolId === 'runSubagent') {
+              // Mark current context as this subagent (for subsequent tool items)
+              currentSubAgentId = sid;
+            }
             if (sid) currentSubAgentId = sid;
             const tool = this._normalizeTool(item);
             if (tool) {
@@ -283,7 +420,6 @@ class VsCodeParser extends BaseSessionParser {
           }
 
           case 'prepareToolInvocation':
-          case 'inlineReference':
           case 'undoStop':
           case 'codeblockUri':
           case 'mcpServersStarting':
@@ -296,49 +432,44 @@ class VsCodeParser extends BaseSessionParser {
       }
 
       flushText(); // flush any trailing text
-
-      // Emit subagent.completed events (proportional estimated endTime) after all items
-      for (const sid of seenSubAgents) {
-        const agentName = subAgentNames[sid] || `subagent-${sid.slice(0, 8)}`;
-        const times = subAgentTimestamps.get(sid);
-        const endTs = times?.endTime || completedAt;
-        events.push({
-          type: 'subagent.completed',
-          id: `${req.requestId}-subagent-${sid}-end`,
-          timestamp: endTs,
-          parentId: req.requestId,
-          data: {
-            toolCallId: sid,
-            agentDisplayName: agentName,
-            agentName: agentName,
-          },
-        });
-      }
     }
 
     return events;
   }
 
   /**
-   * Extract agent name from the first toolInvocationSerialized item for a given subAgentInvocationId.
-   * Looks for .agent.md filename in invocationMessage or resultDetails URIs.
+   * Build a map of subagent id → agent name from runSubagent tool invocations.
+   * runSubagent items: toolId='runSubagent', toolCallId=subagent-id
+   * Agent name is extracted from invocationMessage or resultDetails.
    */
   _buildSubAgentNameMap(items) {
     const nameMap = {};
     for (const item of items) {
       if (!item || typeof item !== 'object') continue;
-      const sid = item.subAgentInvocationId;
-      if (!sid || nameMap[sid]) continue;
       if (item.kind !== 'toolInvocationSerialized') continue;
+      if (item.toolId !== 'runSubagent') continue;
 
-      // Try invocationMessage text for agent file path
+      const sid = item.toolCallId;
+      if (!sid || nameMap[sid]) continue;
+
+      // Prefer agentName from toolSpecificData (e.g. "FoundationAgent")
+      const agentName = item.toolSpecificData?.agentName;
+      if (agentName) { nameMap[sid] = agentName; continue; }
+
+      // Fallback: Use invocationMessage as agent display name
       const msgObj = item.invocationMessage;
-      const msg = (msgObj && typeof msgObj === 'object') ? (msgObj.value || '') : '';
+      const msg = typeof msgObj === 'string' ? msgObj
+        : (msgObj && typeof msgObj === 'object') ? (msgObj.value || '') : '';
+      if (msg) { nameMap[sid] = msg; continue; }
+
+      // Fallback: try agent file path in message
       let m = msg.match(/agents\/([^/\]]+?)\.agent\.md/);
       if (m) { nameMap[sid] = m[1]; continue; }
 
       // Try resultDetails
-      for (const rd of (item.resultDetails || [])) {
+      const resultDetails = item.resultDetails;
+      const rdList = Array.isArray(resultDetails) ? resultDetails : (resultDetails ? [resultDetails] : []);
+      for (const rd of rdList) {
         if (typeof rd !== 'object') continue;
         const fp = rd.fsPath || rd.path || '';
         m = fp.match(/agents\/([^/]+?)\.agent\.md/);
@@ -366,10 +497,57 @@ class VsCodeParser extends BaseSessionParser {
 
     // toolSpecificData may hold input/output depending on tool type
     const tsd = item.toolSpecificData || {};
-    const input = tsd.input || tsd.parameters || tsd.request || {};
-    const result = tsd.output || tsd.result || item.resultDetails || null;
+    let input = tsd.input || tsd.parameters || tsd.request || {};
+    let result = tsd.output || tsd.result || null;
     const isError = item.isConfirmed === false;
 
+    // vscode tools don't serialize input/result into toolSpecificData.
+    // Use invocationMessage as a human-readable description of what the tool did,
+    // and generatedTitle / resultDetails as the result summary.
+    if (!result && (item.generatedTitle || item.resultDetails)) {
+      // resultDetails is an array of URIs (e.g. files found/read)
+      if (item.resultDetails) {
+        const rdList = Array.isArray(item.resultDetails) ? item.resultDetails : [item.resultDetails];
+        const paths = rdList.map(rd => rd.fsPath || rd.path || rd.external || JSON.stringify(rd)).filter(Boolean);
+        result = paths.length > 0 ? paths.join('\n') : item.generatedTitle || null;
+      } else {
+        result = item.generatedTitle || null;
+      }
+    }
+    // Use invocationMessage (plain text) as input description if input is empty
+    if (Object.keys(input).length === 0 && item.invocationMessage) {
+      const msg = item.invocationMessage;
+      const msgText = typeof msg === 'string' ? msg
+        : (msg && typeof msg === 'object') ? (msg.value || '') : '';
+      if (msgText) input = { description: msgText };
+    }
+
+    // Simplify URI objects: replace {$mid, fsPath, external, path, scheme} with just the filename
+    const simplifyUri = (uri) => {
+      if (!uri || typeof uri !== 'object') return uri;
+      const p = uri.fsPath || uri.path || uri.external || '';
+      return p ? p.replace(/.*\//, '') : JSON.stringify(uri);
+    };
+    const simplifyInput = (obj) => {
+      if (!obj || typeof obj !== 'object') return obj;
+      const out = {};
+      for (const [k, v] of Object.entries(obj)) {
+        if (k === '$mid' || k === 'external' || k === 'scheme') continue; // skip internal URI fields
+        if (k === 'fsPath' || k === 'path') { out['file'] = v.replace(/.*\//, ''); continue; }
+        if (v && typeof v === 'object' && ('fsPath' in v || '$mid' in v)) {
+          out[k] = simplifyUri(v);
+        } else if (Array.isArray(v) && k === 'edits') {
+          out['edits'] = `${v.length} edit(s)`;
+        } else {
+          out[k] = v;
+        }
+      }
+      return out;
+    };
+    if (input && typeof input === 'object' && !input.description) {
+      input = simplifyInput(input);
+    }
+
     return {
       type: 'tool_use',
       id: item.toolCallId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qiaolei81/copilot-session-viewer",
-  "version": "0.2.7",
+  "version": "0.3.1",
   "description": "Web UI for viewing GitHub Copilot CLI session logs",
   "author": "Lei Qiao <qiaolei81@gmail.com>",
   "license": "MIT",