@qiaolei81/copilot-session-viewer 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -5,6 +5,30 @@ 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.2] - 2026-03-08
+
+### Fixed
+- **VSCode Session Duration** - Duration now uses the last `terminalCommandState.timestamp` (when the agent actually executed a command) instead of a `toolCount × 3500ms` heuristic. Long-running agentic sessions that span multiple hours are now measured correctly
+- **VSCode Multi-Workspace Dedup** - `_findVsCodeSession` now collects candidates from all matching workspace hashes and returns the one with the latest effective end time (most complete data), instead of returning the first match found
+- **Session `createdAt` in CI** - `Session.fromDirectory` now reads `startTime`/`endTime` from `workspace.yaml` (in addition to `created_at`/`updated_at`), fixing `createdAt` being undefined in environments where `stats.birthtime` is unavailable
+
+### Refactored
+- **`_buildVsCodeSession()`** - Extracted shared VSCode session construction logic into a single method used by both the main scan loop and `_findVsCodeSession`, eliminating duplicate `effectiveEnd2`/`toolCount2` variables
+
+## [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

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/vscode-parser.js

@@ -348,7 +348,14 @@ 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;
           }
 
@@ -413,7 +420,6 @@ class VsCodeParser extends BaseSessionParser {
           }
 
           case 'prepareToolInvocation':
-          case 'inlineReference':
           case 'undoStop':
           case 'codeblockUri':
           case 'mcpServersStarting':

package/package.json

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

package/src/controllers/sessionController.js

@@ -276,59 +276,72 @@ class SessionController {
       let sessionPath;
       let isDirectory = false;
 
-      if (session.source === 'copilot') {
-        const copilotSource = this.sessionService.sessionRepository.sources.find(s => s.type === 'copilot');
-        if (!copilotSource) {
-          return res.status(404).json({ error: 'Copilot source not found' });
-        }
-
-        const basePath = path.join(copilotSource.dir, sessionId);
+      if (session.directory) {
+        // Try session directory first (copilot dirs, vscode dirs)
         try {
-          const stats = await fs.promises.stat(basePath);
+          const stats = await fs.promises.stat(session.directory);
           if (stats.isDirectory()) {
-            sessionPath = basePath;
+            sessionPath = session.directory;
             isDirectory = true;
-          } else {
-            sessionPath = `${basePath}.jsonl`;
           }
         } catch {
-          sessionPath = `${basePath}.jsonl`;
-        }
-      } else if (session.source === 'claude') {
-        const claudeSource = this.sessionService.sessionRepository.sources.find(s => s.type === 'claude');
-        if (!claudeSource) {
-          return res.status(404).json({ error: 'Claude source not found' });
-        }
-
-        // Claude sessions are in projects/*/sessionId.jsonl
-        const projectDirs = await fs.promises.readdir(path.join(claudeSource.dir, 'projects'));
-        for (const projectDir of projectDirs) {
-          const candidatePath = path.join(claudeSource.dir, 'projects', projectDir, `${sessionId}.jsonl`);
-          try {
-            await fs.promises.access(candidatePath);
-            sessionPath = candidatePath;
-            break;
-          } catch {
-            // Try next project
-          }
+          // Fall through to filePath
         }
+      }
 
-        if (!sessionPath) {
-          return res.status(404).json({ error: 'Session file not found' });
-        }
-      } else if (session.source === 'pi-mono') {
-        const piMonoSource = this.sessionService.sessionRepository.sources.find(s => s.type === 'pi-mono');
-        if (!piMonoSource) {
-          return res.status(404).json({ error: 'Pi-Mono source not found' });
+      if (!sessionPath && session.filePath) {
+        // File-based sessions (claude .jsonl, pi-mono .jsonl, copilot .jsonl)
+        try {
+          await fs.promises.access(session.filePath);
+          sessionPath = session.filePath;
+        } catch {
+          // Not accessible
         }
+      }
 
-        // Pi-Mono sessions are timestamp-based JSONL files
-        const files = await fs.promises.readdir(piMonoSource.dir);
-        const matchingFile = files.find(f => f.includes(sessionId) && f.endsWith('.jsonl'));
-        if (!matchingFile) {
-          return res.status(404).json({ error: 'Session file not found' });
+      // Legacy source-specific lookup as fallback
+      if (!sessionPath) {
+        if (session.source === 'copilot') {
+          const copilotSource = this.sessionService.sessionRepository.sources.find(s => s.type === 'copilot');
+          if (copilotSource) {
+            const basePath = path.join(copilotSource.dir, sessionId);
+            try {
+              const stats = await fs.promises.stat(basePath);
+              if (stats.isDirectory()) {
+                sessionPath = basePath;
+                isDirectory = true;
+              } else {
+                sessionPath = `${basePath}.jsonl`;
+              }
+            } catch {
+              sessionPath = `${basePath}.jsonl`;
+            }
+          }
+        } else if (session.source === 'claude') {
+          const claudeSource = this.sessionService.sessionRepository.sources.find(s => s.type === 'claude');
+          if (claudeSource) {
+            const projectDirs = await fs.promises.readdir(path.join(claudeSource.dir, 'projects'));
+            for (const projectDir of projectDirs) {
+              const candidatePath = path.join(claudeSource.dir, 'projects', projectDir, `${sessionId}.jsonl`);
+              try {
+                await fs.promises.access(candidatePath);
+                sessionPath = candidatePath;
+                break;
+              } catch {
+                // Try next project
+              }
+            }
+          }
+        } else if (session.source === 'pi-mono') {
+          const piMonoSource = this.sessionService.sessionRepository.sources.find(s => s.type === 'pi-mono');
+          if (piMonoSource) {
+            const files = await fs.promises.readdir(piMonoSource.dir);
+            const matchingFile = files.find(f => f.includes(sessionId) && f.endsWith('.jsonl'));
+            if (matchingFile) {
+              sessionPath = path.join(piMonoSource.dir, matchingFile);
+            }
+          }
         }
-        sessionPath = path.join(piMonoSource.dir, matchingFile);
       }
 
       if (!sessionPath) {
@@ -346,12 +359,23 @@ class SessionController {
       const zip = new AdmZip();
 
       if (isDirectory) {
-        // Add entire directory
+        // Add entire directory (includes tags.json if present)
         zip.addLocalFolder(sessionPath, sessionId);
       } else {
-        // Add single file
+        // Add session file
         const fileName = path.basename(sessionPath);
         zip.addLocalFile(sessionPath, '', fileName);
+
+        // Also include tags file if it exists
+        const TagService = require('../services/tagService');
+        const tagService = new TagService();
+        const tagsFilePath = tagService.getSessionTagsFilePath(session);
+        try {
+          await fs.promises.access(tagsFilePath);
+          zip.addLocalFile(tagsFilePath, '', path.basename(tagsFilePath));
+        } catch {
+          // No tags file, skip
+        }
       }
 
       // Send zip file

package/src/models/Session.js

@@ -40,11 +40,21 @@ class Session {
    * @returns {Session}
    */
   static fromDirectory(dirPath, id, stats, workspace, eventCount, duration, isImported, hasInsight, copilotVersion, selectedModel, sessionStatus) {
+    const createdAt = workspace?.created_at
+      ? new Date(workspace.created_at)
+      : workspace?.startTime
+        ? new Date(workspace.startTime)
+        : stats.birthtime;
+    const updatedAt = workspace?.updated_at
+      ? new Date(workspace.updated_at)
+      : workspace?.endTime
+        ? new Date(workspace.endTime)
+        : stats.mtime;
     return new Session(id, 'directory', {
       directory: dirPath, // Add directory path
       workspace: workspace,
-      createdAt: workspace?.created_at || stats.birthtime,
-      updatedAt: workspace?.updated_at || stats.mtime,
+      createdAt,
+      updatedAt,
       summary: workspace?.summary || 'No summary',
       hasEvents: eventCount > 0,
       eventCount: eventCount,
@@ -72,6 +82,7 @@ class Session {
    */
   static fromFile(filePath, id, stats, eventCount, summary, duration, copilotVersion, selectedModel, sessionStatus) {
     return new Session(id, 'file', {
+      filePath: filePath,
       directory: path.dirname(filePath), // Directory containing the file
       createdAt: stats.birthtime,
       updatedAt: stats.mtime,

package/src/services/insightService.js

@@ -60,8 +60,9 @@ class InsightService {
    * @returns {Promise<Object>} Insight status and report
    */
   async generateInsight(sessionId, sessionPath, source = 'copilot', forceRegenerate = false) {
-    const insightFile = path.join(sessionPath, 'agent-review.md');
-    const lockFile = path.join(sessionPath, 'agent-review.md.lock');
+    // Use per-session insight file to avoid collisions in shared directories
+    const insightFile = path.join(sessionPath, `${sessionId}.agent-review.md`);
+    const lockFile = path.join(sessionPath, `${sessionId}.agent-review.md.lock`);
     
     // Determine events file location based on directory structure
     // Try standard events.jsonl first, then <sessionId>.jsonl (for file-type sessions),
@@ -184,7 +185,7 @@ class InsightService {
     await fs.mkdir(tmpDir, { recursive: true});
 
     const prompt = this._buildPrompt(insightFile, eventsFile);
-    const outputFile = path.join(sessionPath, 'agent-review.md.tmp');
+    const outputFile = path.join(sessionPath, `${sessionId}.agent-review.md.tmp`);
 
     // Spawn analysis tool directly (no shell)
     const cliPath = toolConfig.cli;
@@ -451,17 +452,17 @@ IMPORTANT CONSTRAINTS:
    * @returns {Promise<Object>} Status object
    */
   async getInsightStatus(sessionId, sessionPath, _source = 'copilot') {
-    return await this._getStatusForSource(sessionPath);
+    return await this._getStatusForSource(sessionId, sessionPath);
   }
 
   /**
    * Get status for a specific session directory
    * @private
    */
-  async _getStatusForSource(sessionPath) {
-    const insightFile = path.join(sessionPath, 'agent-review.md');
-    const lockFile = path.join(sessionPath, 'agent-review.md.lock');
-    const tmpFile = path.join(sessionPath, 'agent-review.md.tmp');
+  async _getStatusForSource(sessionId, sessionPath) {
+    const insightFile = path.join(sessionPath, `${sessionId}.agent-review.md`);
+    const lockFile = path.join(sessionPath, `${sessionId}.agent-review.md.lock`);
+    const tmpFile = path.join(sessionPath, `${sessionId}.agent-review.md.tmp`);
 
     try {
       const report = await fs.readFile(insightFile, 'utf-8');
@@ -517,7 +518,7 @@ IMPORTANT CONSTRAINTS:
    * @returns {Promise<Object>} Result object
    */
   async deleteInsight(sessionId, sessionPath, _source = 'copilot') {
-    const insightFile = path.join(sessionPath, 'agent-review.md');
+    const insightFile = path.join(sessionPath, `${sessionId}.agent-review.md`);
 
     try {
       await fs.unlink(insightFile);

package/src/services/sessionRepository.js

@@ -48,6 +48,23 @@ class SessionRepository {
     }
     
     this.parserFactory = new ParserFactory();
+    
+    // Cache: keyed by sourceType (null = all sources)
+    this._cache = new Map();
+    this._cacheTTL = 60 * 1000; // 60 seconds
+    this._pendingScans = new Map(); // dedup concurrent requests
+  }
+
+  /**
+   * Invalidate cache (call after tag/insight changes if needed)
+   */
+  invalidateCache(sourceType = null) {
+    if (sourceType) {
+      this._cache.delete(sourceType);
+      this._cache.delete(null); // also invalidate "all" cache
+    } else {
+      this._cache.clear();
+    }
   }
 
   /**
@@ -56,6 +73,36 @@ class SessionRepository {
    * @returns {Promise<Session[]>} Array of sessions sorted by updatedAt (newest first)
    */
   async findAll(sourceType = null) {
+    const cacheKey = sourceType || '__all__';
+    
+    // Check cache
+    const cached = this._cache.get(cacheKey);
+    if (cached && (Date.now() - cached.timestamp < this._cacheTTL)) {
+      return cached.data;
+    }
+
+    // Dedup concurrent scans for same key
+    if (this._pendingScans.has(cacheKey)) {
+      return this._pendingScans.get(cacheKey);
+    }
+
+    const scanPromise = this._doFindAll(sourceType).then(result => {
+      this._cache.set(cacheKey, { data: result, timestamp: Date.now() });
+      this._pendingScans.delete(cacheKey);
+      return result;
+    }).catch(err => {
+      this._pendingScans.delete(cacheKey);
+      throw err;
+    });
+
+    this._pendingScans.set(cacheKey, scanPromise);
+    return scanPromise;
+  }
+
+  /**
+   * @private
+   */
+  async _doFindAll(sourceType = null) {
     const allSessions = [];
 
     const sources = sourceType
@@ -71,7 +118,23 @@ class SessionRepository {
       }
     }
 
-    return this._sortByUpdatedAt(allSessions);
+    return this._sortByUpdatedAt(this._deduplicateSessions(allSessions));
+  }
+
+  /**
+   * Deduplicate sessions with the same ID (e.g. VSCode sessions in multiple workspaces).
+   * Keeps the most recently updated session for each ID.
+   * @private
+   */
+  _deduplicateSessions(sessions) {
+    const seen = new Map();
+    for (const session of sessions) {
+      const existing = seen.get(session.id);
+      if (!existing || (session.updatedAt && existing.updatedAt && new Date(session.updatedAt) > new Date(existing.updatedAt))) {
+        seen.set(session.id, session);
+      }
+    }
+    return Array.from(seen.values());
   }
 
   /**
@@ -234,6 +297,7 @@ class SessionRepository {
 
       return new Session(sessionId, 'file', {
         source: 'claude',
+        filePath: fullPath,
         directory: path.dirname(fullPath), // Directory containing the session file
         workspace: {
           summary: metadata.model ? `Claude Code session (${metadata.model})` : 'Claude Code session',
@@ -415,6 +479,7 @@ class SessionRepository {
                   'directory',
                   {
                     source: 'pi-mono',
+                    filePath: filePath,
                     directory: projectPath, // Project directory containing the session file
                     workspace: { cwd: sessionEvent.cwd || projectName },
                     createdAt: new Date(sessionEvent.timestamp),
@@ -447,6 +512,8 @@ class SessionRepository {
   async _findVsCodeSession(sessionId, workspaceStorageDir) {
     try {
       const hashes = await fs.readdir(workspaceStorageDir);
+      const candidates = [];
+
       for (const hash of hashes) {
         const chatSessionsDir = path.join(workspaceStorageDir, hash, 'chatSessions');
         try {
@@ -464,58 +531,24 @@ class SessionRepository {
               sessionJson = JSON.parse(raw);
             }
             const requests = sessionJson.requests || [];
-            if (requests.length === 0) return null;
-
-            const firstReq = requests[0];
-            const createdAt = sessionJson.creationDate
-              ? new Date(sessionJson.creationDate)
-              : (firstReq.timestamp ? new Date(firstReq.timestamp) : stats.birthtime);
-            const lastReqTime2 = requests[requests.length - 1].timestamp ? new Date(requests[requests.length - 1].timestamp) : null;
-            const updatedAt = sessionJson.lastMessageDate
-              ? new Date(sessionJson.lastMessageDate)
-              : (lastReqTime2 || stats.mtime);
-            const userText = this._extractVsCodeUserText(firstReq.message);
-
-            const copilotChatVersion = firstReq.agent?.extensionVersion || null;
-            const realWorkspacePath = await this._resolveVsCodeWorkspacePath(path.join(workspaceStorageDir, hash));
+            if (requests.length === 0) continue;
 
-            // Same estimation logic as scan path
-            const _fileMtime2 = stats.mtime;
-            // Count tools for estimation
-            let toolCount2 = 0;
-            for (const req of requests) {
-              toolCount2 += (req.response || []).filter(r => r.kind === 'toolInvocationSerialized').length;
-            }
-            let effectiveEnd2;
-            if (toolCount2 > 10 && lastReqTime2) {
-              const estimatedDurationMs2 = Math.max(toolCount2 * 3500, 60000);
-              effectiveEnd2 = new Date(createdAt.getTime() + estimatedDurationMs2);
-            } else if (lastReqTime2) {
-              effectiveEnd2 = lastReqTime2;
-            } else {
-              effectiveEnd2 = updatedAt;
-            }
-
-            return new Session(sessionId, 'file', {
-              source: 'vscode',
-              filePath: fullPath,
-              workspaceHash: hash,
-              createdAt,
-              updatedAt: effectiveEnd2,
-              summary: userText ? userText.slice(0, 120) : `VSCode chat (${requests.length} requests)`,
-              hasEvents: true,
-              eventCount: requests.reduce((s, r) => s + (r.response || []).length, 0) + requests.length * 2 + 1,
-              duration: effectiveEnd2.getTime() - createdAt.getTime(),
-              sessionStatus: (Date.now() - effectiveEnd2.getTime()) < 5 * 60 * 1000 ? 'wip' : 'completed',
-              selectedModel: firstReq.modelId || null,
-              copilotVersion: copilotChatVersion,
-              workspace: { cwd: realWorkspacePath || path.join(workspaceStorageDir, hash) },
-            });
+            const realWorkspacePath = await this._resolveVsCodeWorkspacePath(path.join(workspaceStorageDir, hash));
+            const statsWithPath = { ...stats, filePath: fullPath };
+            candidates.push(this._buildVsCodeSession(
+              sessionId, requests, sessionJson, statsWithPath, hash,
+              realWorkspacePath || path.join(workspaceStorageDir, hash)
+            ));
           }
         } catch {
           // No chatSessions dir or can't read — skip
         }
       }
+      // Return the candidate with the latest effectiveEndTime (most complete data)
+      if (candidates.length > 0) {
+        candidates.sort((a, b) => (b.updatedAt?.getTime?.() ?? 0) - (a.updatedAt?.getTime?.() ?? 0));
+        return candidates[0];
+      }
     } catch (err) {
       console.error(`[VSCode findById] Error searching VSCode sessions: ${err.message}`, err.stack);
     }
@@ -592,7 +625,7 @@ class SessionRepository {
     const workspaceFile = path.join(fullPath, 'workspace.yaml');
     const eventsFile = path.join(fullPath, 'events.jsonl');
     const importedMarkerFile = path.join(fullPath, '.imported');
-    const insightReportFile = path.join(fullPath, 'agent-review.md');
+    const insightReportFile = path.join(fullPath, `${entry}.agent-review.md`);
 
     // Parse workspace.yaml if exists, otherwise use defaults
     const workspace = await fileExists(workspaceFile) 
@@ -620,6 +653,15 @@ class SessionRepository {
       if (!workspace.summary && optimizedMetadata.firstUserMessage) {
         workspace.summary = optimizedMetadata.firstUserMessage;
       }
+
+      // Use max of filesystem mtime and last event timestamp for updatedAt
+      if (optimizedMetadata.lastEventTime) {
+        const lastEventMs = new Date(optimizedMetadata.lastEventTime).getTime();
+        const mtimeMs = new Date(stats.mtime).getTime();
+        if (lastEventMs > mtimeMs) {
+          stats = { ...stats, mtime: new Date(lastEventMs) };
+        }
+      }
     }
 
     const session = Session.fromDirectory(fullPath, entry, stats, workspace, eventCount, duration, isImported, hasInsight, copilotVersion, selectedModel, sessionStatus);
@@ -897,68 +939,11 @@ class SessionRepository {
         const requests = sessionJson.requests || [];
         if (requests.length === 0) continue;
 
-        const firstReq = requests[0];
-        const lastReq = requests[requests.length - 1];
-        const createdAt = sessionJson.creationDate
-          ? new Date(sessionJson.creationDate)
-          : (firstReq.timestamp ? new Date(firstReq.timestamp) : stats.birthtime);
-        const lastReqTime = lastReq.timestamp ? new Date(lastReq.timestamp) : null;
-        const updatedAt = sessionJson.lastMessageDate
-          ? new Date(sessionJson.lastMessageDate)
-          : (lastReqTime || stats.mtime);
-
-        // Count tool invocations across all requests (must be before effectiveEndTime calc)
-        let toolCount = 0;
-        for (const req of requests) {
-          toolCount += (req.response || []).filter(r => r.kind === 'toolInvocationSerialized').length;
-        }
-
-        // For VSCode agentic sessions, file mtime may be more accurate than last request timestamp
-        // because sub-agents write incremental updates over time without new request timestamps.
-        // BUT: VSCode may touch/sync all files at once, creating misleading mtimes.
-        // Strategy: 
-        //   - If session has many tool invocations (agentic), estimate duration from tool count
-        //   - Otherwise fall back to request timestamps
-        const _fileMtime = stats.mtime;
-        let effectiveEndTime;
-        if (toolCount > 10 && lastReqTime) {
-          // Agentic session: estimate ~3.5s per tool invocation as a rough heuristic
-          const estimatedDurationMs = Math.max(toolCount * 3500, 60000); // at least 1 min
-          const estimatedEnd = new Date(createdAt.getTime() + estimatedDurationMs);
-          effectiveEndTime = estimatedEnd;
-        } else if (lastReqTime) {
-          effectiveEndTime = lastReqTime;
-        } else {
-          effectiveEndTime = updatedAt;
-        }
-
-        const model = firstReq.modelId || null;
-        const agentId = firstReq.agent?.id || 'vscode-copilot';
-        const copilotChatVersion = firstReq.agent?.extensionVersion || null;
-        const userText = this._extractVsCodeUserText(firstReq.message);
-
-        const session = new Session(
-          sessionId,
-          'file',
-          {
-            source: 'vscode',
-            filePath: fullPath,
-            workspaceHash,
-            createdAt,
-            updatedAt: effectiveEndTime,
-            summary: userText ? userText.slice(0, 120) : `VSCode chat (${requests.length} requests)`,
-            hasEvents: true,
-            eventCount: requests.reduce((s, r) => s + (r.response || []).length, 0) + requests.length * 2 + 1,
-            duration: effectiveEndTime.getTime() - createdAt.getTime(),
-            sessionStatus: (Date.now() - effectiveEndTime.getTime()) < 5 * 60 * 1000 ? 'wip' : 'completed',
-            selectedModel: model,
-            agentId,
-            toolCount,
-            copilotVersion: copilotChatVersion,
-            workspace: { cwd: realWorkspacePath || workspaceHashDir },
-          }
+        const statsWithPath = { ...stats, filePath: fullPath };
+        const session = this._buildVsCodeSession(
+          sessionId, requests, sessionJson, statsWithPath, workspaceHash,
+          realWorkspacePath || workspaceHashDir
         );
-
         sessions.push(session);
       } catch (err) {
         // Skip malformed files silently
@@ -968,6 +953,76 @@ class SessionRepository {
   }
 
   /** Extract plain text from a VSCode message object */
+  /**
+   * Build a VSCode Session object from parsed JSONL data.
+   * Single source of truth for VSCode session construction — used by both
+   * the main scan loop and _findVsCodeSession to avoid duplicate logic.
+   * @private
+   */
+  _buildVsCodeSession(sessionId, requests, sessionJson, stats, workspaceHash, workspaceCwd) {
+    const firstReq = requests[0];
+    const lastReq = requests[requests.length - 1];
+
+    const createdAt = sessionJson.creationDate
+      ? new Date(sessionJson.creationDate)
+      : (firstReq.timestamp ? new Date(firstReq.timestamp) : stats.birthtime);
+
+    const lastReqTime = lastReq.timestamp ? new Date(lastReq.timestamp) : null;
+    const fallbackUpdatedAt = sessionJson.lastMessageDate
+      ? new Date(sessionJson.lastMessageDate)
+      : (lastReqTime || stats.mtime);
+
+    // Use last terminal command timestamp (truest end time for agentic sessions).
+    // terminalCommandState.timestamp = when the agent actually executed a command.
+    // request.timestamp = when the user sent the message (start of turn, not end).
+    // mtime is unreliable — VSCode syncs/touches all files when the workspace opens.
+    const lastTerminalTime = this._extractLastTerminalTimestamp(requests);
+    const effectiveEndTime = lastTerminalTime || lastReqTime || fallbackUpdatedAt;
+
+    const isWip = (Date.now() - effectiveEndTime.getTime()) < 15 * 60 * 1000;
+    const userText = this._extractVsCodeUserText(firstReq.message);
+    const toolCount = requests.reduce(
+      (sum, req) => sum + (req.response || []).filter(r => r.kind === 'toolInvocationSerialized').length,
+      0
+    );
+
+    return new Session(sessionId, 'file', {
+      source: 'vscode',
+      filePath: stats.filePath,
+      workspaceHash,
+      createdAt,
+      updatedAt: effectiveEndTime,
+      summary: userText ? userText.slice(0, 120) : `VSCode chat (${requests.length} requests)`,
+      hasEvents: true,
+      eventCount: requests.reduce((s, r) => s + (r.response || []).length, 0) + requests.length * 2 + 1,
+      duration: effectiveEndTime.getTime() - createdAt.getTime(),
+      sessionStatus: isWip ? 'wip' : 'completed',
+      selectedModel: firstReq.modelId || null,
+      agentId: firstReq.agent?.id || 'vscode-copilot',
+      toolCount,
+      copilotVersion: firstReq.agent?.extensionVersion || null,
+      workspace: { cwd: workspaceCwd },
+    });
+  }
+
+  _extractLastTerminalTimestamp(requests) {
+    let maxTs = 0;
+
+    function walk(obj) {
+      if (!obj || typeof obj !== 'object') return;
+      if (Array.isArray(obj)) { obj.forEach(walk); return; }
+      if (obj.terminalCommandState && typeof obj.terminalCommandState.timestamp === 'number') {
+        const ts = obj.terminalCommandState.timestamp;
+        if (ts > 1_000_000_000_000 && ts < 9_999_999_999_999 && ts > maxTs) maxTs = ts;
+      }
+      for (const val of Object.values(obj)) walk(val);
+    }
+
+    for (const req of requests) walk(req.response);
+
+    return maxTs > 0 ? new Date(maxTs) : null;
+  }
+
   _extractVsCodeUserText(message) {
     if (!message) return '';
     if (typeof message.text === 'string') return message.text;

package/src/services/tagService.js

@@ -56,10 +56,18 @@ class TagService {
    * @returns {string} Path to tags.json
    */
   getSessionTagsFilePath(session) {
-    if (!session.directory) {
-      throw new Error('Session must have a directory field');
+    // File-based sessions (e.g. Claude .jsonl): per-file tags to avoid sharing
+    if (session.filePath) {
+      const dir = path.dirname(session.filePath);
+      const base = path.basename(session.filePath, path.extname(session.filePath));
+      return path.join(dir, `${base}.tags.json`);
     }
-    return path.join(session.directory, 'tags.json');
+    // Directory-based sessions (e.g. Copilot CLI): tags.json inside session dir
+    if (session.directory) {
+      return path.join(session.directory, 'tags.json');
+    }
+    // Fallback: store in central location by session id
+    return path.join(this.knownTagsDir, 'session-tags', `${session.id}.tags.json`);
   }
 
   /**
@@ -130,6 +138,8 @@ class TagService {
         // File doesn't exist, ignore
       }
     } else {
+      // Ensure directory exists for tags file
+      await fs.mkdir(path.dirname(tagsFilePath), { recursive: true });
       // Write tags to session directory
       await fs.writeFile(tagsFilePath, JSON.stringify(normalizedTags, null, 2), 'utf8');
 

package/src/utils/fileUtils.js

@@ -146,7 +146,8 @@ async function getSessionMetadataOptimized(filePath, maxMessageLength = 200) {
       copilotVersion: copilotVersion || null,
       selectedModel: selectedModel || null,
       hasSessionEnd,
-      lastEventTime: lastTimestamp
+      lastEventTime: lastTimestamp,
+      firstEventTime: firstTimestamp
     };
   } catch (err) {
     console.error(`Error reading session metadata from ${filePath}:`, err.message);

package/views/time-analyze.ejs

@@ -2211,7 +2211,21 @@
               if (items[i].rowType === 'user-req') break; // next user-req
               if (items[i].rowType === 'subagent') children.push(items[i]);
             }
-            if (children.length === 0) return { left: '0%', width: '0%' };
+            if (children.length === 0) {
+              // No subagents — position this user-req at the end of previous subagents
+              // by finding cumulative tool count up to this point
+              const subagentItems = items.filter(it => it.rowType !== 'user-req');
+              const totalToolCount = subagentItems.reduce((sum, it) => sum + (it.toolCount || 0), 0);
+              if (totalToolCount === 0) return { left: '0%', width: '0%' };
+              // Sum tools of all subagents before this user-req in the items array
+              let cumTools = 0;
+              for (let i = 0; i < idx; i++) {
+                if (items[i].rowType === 'subagent') cumTools += (items[i].toolCount || 0);
+              }
+              const leftPct = (cumTools / totalToolCount) * 100;
+              // Minimal width bar (at least 1%)
+              return { left: leftPct + '%', width: Math.max(1, (1 / totalToolCount) * 100) + '%' };
+            }
             
             const firstPos = ganttSequencePosition(children[0]);
             const lastPos = ganttSequencePosition(children[children.length - 1]);