@qiaolei81/copilot-session-viewer 0.3.1 → 0.3.3

package/src/app.js

@@ -9,7 +9,7 @@ const config = require('./config');
 // Middleware
 // Rate limiting disabled for local development
 // const { globalLimiter, insightGenerationLimiter, insightAccessLimiter, uploadLimiter } = require('./middleware/rateLimiting');
-const { requestTimeout, developmentCors, errorHandler, notFoundHandler } = require('./middleware/common');
+const { requestTimeout, developmentCors, errorHandler, notFoundHandler, telemetryLocals } = require('./middleware/common');
 
 // Controllers
 const SessionController = require('./controllers/sessionController');
@@ -68,6 +68,7 @@ function createApp(options = {}) {
   app.use(express.json({ limit: '1mb' }));
   app.use(express.urlencoded({ extended: true }));
   app.use(requestTimeout);
+  app.use(telemetryLocals);
 
   // CORS in development
   if (config.NODE_ENV === 'development') {

package/src/controllers/insightController.js

@@ -1,5 +1,6 @@
 const InsightService = require('../services/insightService');
 const { isValidSessionId } = require('../utils/helpers');
+const { trackEvent, trackMetric, trackException } = require('../telemetry');
 
 class InsightController {
   constructor(insightService = null, sessionService = null) {
@@ -39,10 +40,30 @@ class InsightController {
         return res.status(400).json({ error: 'Session directory not available' });
       }
 
+      const startTime = Date.now();
       const result = await this.insightService.generateInsight(session.id, session.directory, session.source, forceRegenerate);
+      const durationMs = Date.now() - startTime;
+
+      // Track InsightGenerated event
+      trackEvent('InsightGenerated', {
+        sessionId,
+        source: session.source || 'unknown',
+        durationMs: durationMs.toString()
+      });
+
+      // Track InsightGenerationTime metric
+      trackMetric('InsightGenerationTime', durationMs, { sessionId, source: session.source || 'unknown' });
+
       res.json(result);
     } catch (err) {
       console.error('Error generating insight:', err);
+
+      // Track insight generation failure
+      trackException(err, {
+        sessionId: req.params.id,
+        operation: 'generateInsight'
+      });
+
       res.status(500).json({ error: err.message || 'Error generating insight' });
     }
   }
@@ -67,6 +88,12 @@ class InsightController {
       }
 
       const result = await this.insightService.getInsightStatus(session.id, session.directory, session.source);
+
+      // Track InsightViewed event if insight is ready
+      if (result.status === 'ready' && result.report) {
+        trackEvent('InsightViewed', { sessionId });
+      }
+
       res.json(result);
     } catch (err) {
       console.error('Error getting insight status:', err);
@@ -94,6 +121,10 @@ class InsightController {
       }
 
       const result = await this.insightService.deleteInsight(session.id, session.directory, session.source);
+
+      // Track InsightDeleted event
+      trackEvent('InsightDeleted', { sessionId });
+
       res.json(result);
     } catch (err) {
       console.error('Error deleting insight:', err);

package/src/controllers/sessionController.js

@@ -1,5 +1,6 @@
 const SessionService = require('../services/sessionService');
 const { isValidSessionId, buildMetadata } = require('../utils/helpers');
+const { trackEvent, trackMetric } = require('../telemetry');
 const AdmZip = require('adm-zip');
 const path = require('path');
 const fs = require('fs');
@@ -40,6 +41,12 @@ class SessionController {
         sourceHints: JSON.stringify(sourceHints)
       };
 
+      // Track HomepageViewed event
+      trackEvent('HomepageViewed', {
+        sessionCount: paginationData.totalSessions.toString(),
+        sourceFilter: 'copilot'
+      });
+
       res.render('index', templateData);
     } catch (err) {
       console.error('Error loading sessions:', err);
@@ -62,6 +69,29 @@ class SessionController {
       }
 
       const metadata = buildMetadata(session);
+
+      // Track SessionViewed event
+      trackEvent('SessionViewed', {
+        sessionId,
+        source: session.source || 'unknown',
+        eventCount: (session.eventCount || metadata.totalEvents || 0).toString(),
+        duration: (session.duration || metadata.duration || 0).toString(),
+        model: session.model || metadata.model || 'unknown',
+        sessionStatus: session.status || metadata.status || 'unknown'
+      });
+
+      // Track SessionEventCount metric
+      const eventCount = session.eventCount || metadata.totalEvents || 0;
+      if (eventCount > 0) {
+        trackMetric('SessionEventCount', eventCount, { sessionId, source: session.source || 'unknown' });
+      }
+
+      // Track SessionDuration metric
+      const duration = session.duration || metadata.duration || 0;
+      if (duration > 0) {
+        trackMetric('SessionDuration', duration, { sessionId, source: session.source || 'unknown' });
+      }
+
       res.render('session-vue', { sessionId, events: [], metadata });
     } catch (err) {
       console.error('Error loading session:', err);
@@ -84,6 +114,13 @@ class SessionController {
       }
 
       const metadata = buildMetadata(session);
+
+      // Track TimeAnalysisViewed event
+      trackEvent('TimeAnalysisViewed', {
+        sessionId,
+        turnCount: (metadata.totalEvents || 0).toString()
+      });
+
       res.render('time-analyze', { sessionId, events: [], metadata });
     } catch (err) {
       console.error('Error loading time analysis:', err);
@@ -104,6 +141,14 @@ class SessionController {
           return res.status(400).json({ error: 'Invalid pagination parameters' });
         }
         const paginationData = await this.sessionService.getPaginatedSessions(page, limit, sourceFilter);
+
+        // Track SessionListLoaded event for API pagination
+        trackEvent('SessionListLoaded', {
+          page: page.toString(),
+          limit: limit.toString(),
+          totalSessions: paginationData.totalSessions.toString()
+        });
+
         res.set({ 'Cache-Control': 'public, max-age=60' });
         res.json(paginationData);
       } else if (sourceFilter && limit) {
@@ -140,6 +185,13 @@ class SessionController {
       const page = Math.floor(offset / limit) + 1;
       const paginationData = await this.sessionService.getPaginatedSessions(page, limit, sourceFilter);
 
+      // Track SessionListLoaded event
+      trackEvent('SessionListLoaded', {
+        page: page.toString(),
+        limit: limit.toString(),
+        totalSessions: paginationData.totalSessions.toString()
+      });
+
       res.json({
         sessions: paginationData.sessions,
         hasMore: paginationData.hasNextPage,
@@ -382,6 +434,10 @@ class SessionController {
       const zipBuffer = zip.toBuffer();
       res.setHeader('Content-Type', 'application/zip');
       res.setHeader('Content-Disposition', `attachment; filename="session-${sessionId}.zip"`);
+
+      // Track SessionExported event
+      trackEvent('SessionExported', { sessionId });
+
       res.send(zipBuffer);
     } catch (err) {
       console.error('Error exporting session:', err);

package/src/controllers/tagController.js

@@ -1,6 +1,7 @@
 const TagService = require('../services/tagService');
 const SessionRepository = require('../services/sessionRepository');
 const { isValidSessionId } = require('../utils/helpers');
+const { trackEvent } = require('../telemetry');
 
 class TagController {
   constructor(tagService = null, sessionRepository = null) {
@@ -88,6 +89,13 @@ class TagController {
       }
 
       const savedTags = await this.tagService.setSessionTags(session, tags);
+
+      // Track TagUpdated event
+      trackEvent('TagUpdated', {
+        sessionId,
+        tagCount: savedTags.length.toString()
+      });
+
       res.json({ tags: savedTags });
     } catch (err) {
       console.error('Error setting session tags:', err);

package/src/controllers/uploadController.js

@@ -4,6 +4,7 @@ const os = require('os');
 const multer = require('multer');
 const { spawn } = require('child_process');
 const { isValidSessionId } = require('../utils/helpers');
+const { trackEvent, trackException } = require('../telemetry');
 const processManager = require('../utils/processManager');
 const config = require('../config');
 
@@ -72,6 +73,9 @@ class UploadController {
           return res.status(500).json({ error: 'Failed to create zip file' });
         }
 
+        // Track SessionShared event
+        trackEvent('SessionShared', { sessionId });
+
         res.download(zipFile, `session-${sessionId}.zip`, (err) => {
           fs.promises.unlink(zipFile).catch(() => {});
           if (err) {
@@ -181,6 +185,7 @@ class UploadController {
       processManager.register(unzipProcess, { name: 'unzip-import' });
 
       unzipProcess.on('close', async (code) => {
+        let sessionDirName; // Declare here for access in catch block
         try {
           await fs.promises.unlink(zipPath);
 
@@ -195,7 +200,7 @@ class UploadController {
             return res.status(400).json({ error: 'Empty zip file' });
           }
 
-          const sessionDirName = entries[0];
+          sessionDirName = entries[0];
 
           // Validate session directory name to prevent Zip Slip path traversal
           if (!isValidSessionId(sessionDirName)) {
@@ -222,9 +227,23 @@ class UploadController {
           await fs.promises.rename(sessionPath, targetPath);
           await fs.promises.rm(extractDir, { recursive: true, force: true });
 
+          // Track SessionImported event
+          const stats = await fs.promises.stat(zipPath).catch(() => ({ size: 0 }));
+          trackEvent('SessionImported', {
+            format: 'copilot',
+            fileSize: stats.size.toString()
+          });
+
           res.json({ success: true, sessionId: sessionDirName });
         } catch (err) {
           console.error('Error importing session:', err);
+
+          // Track import failure
+          trackException(err, {
+            operation: 'importSession',
+            sessionId: sessionDirName || 'unknown'
+          });
+
           await fs.promises.rm(extractDir, { recursive: true, force: true }).catch(() => {});
           res.status(500).json({ error: 'Error importing session' });
         }
@@ -232,12 +251,24 @@ class UploadController {
 
       unzipProcess.on('error', async (err) => {
         console.error('Error extracting zip:', err);
+
+        // Track upload/extraction failure
+        trackException(err, {
+          operation: 'importSession_unzip'
+        });
+
         await fs.promises.unlink(zipPath).catch(() => {});
         await fs.promises.rm(extractDir, { recursive: true, force: true }).catch(() => {});
         res.status(500).json({ error: 'Failed to extract zip file' });
       });
     } catch (err) {
       console.error('Error processing upload:', err);
+
+      // Track upload processing failure
+      trackException(err, {
+        operation: 'importSession_upload'
+      });
+
       if (req.file) {
         await fs.promises.unlink(req.file.path).catch(() => {});
       }

package/src/middleware/common.js

@@ -1,4 +1,5 @@
 const config = require('../config');
+const { trackException, isEnabled: isTelemetryEnabled } = require('../telemetry');
 
 // Request timeout middleware
 const requestTimeout = (req, res, next) => {
@@ -6,6 +7,15 @@ const requestTimeout = (req, res, next) => {
   next();
 };
 
+// Telemetry middleware - makes telemetry settings available to templates
+const telemetryLocals = (req, res, next) => {
+  res.locals.telemetryEnabled = isTelemetryEnabled;
+  res.locals.telemetryConnectionString = isTelemetryEnabled
+    ? (process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || 'InstrumentationKey=39f4fbf1-d82f-42c3-b4ef-ea92a1fd82cb;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=7d4bb432-f2f5-4526-a5e6-31901e5a2db2')
+    : null;
+  next();
+};
+
 // CORS middleware for development
 const developmentCors = (req, res, next) => {
   if (config.NODE_ENV === 'development') {
@@ -24,6 +34,14 @@ const developmentCors = (req, res, next) => {
 const errorHandler = (err, req, res, _next) => {
   console.error('Unhandled error:', err.stack);
 
+  // Track exception in Application Insights
+  trackException(err, {
+    url: req.url,
+    method: req.method,
+    statusCode: (err.status || 500).toString(),
+    userAgent: (req.headers && req.headers['user-agent']) || 'unknown'
+  });
+
   const statusCode = err.status || 500;
   // Default to production-safe behavior if NODE_ENV is not set
   const isDevelopment = config.NODE_ENV === 'development';
@@ -44,5 +62,6 @@ module.exports = {
   requestTimeout,
   developmentCors,
   errorHandler,
-  notFoundHandler
+  notFoundHandler,
+  telemetryLocals
 };

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,

package/src/services/sessionRepository.js

@@ -512,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 {
@@ -529,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()) < 15 * 60 * 1000 || (Date.now() - stats.mtime.getTime()) < 15 * 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);
     }
@@ -685,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);
@@ -727,7 +704,7 @@ class SessionRepository {
       return 'completed';
     }
     if (metadata.lastEventTime !== null && metadata.lastEventTime !== undefined) {
-      const WIP_THRESHOLD_MS = 15 * 60 * 1000;
+      const WIP_THRESHOLD_MS = 5 * 60 * 1000;
       if ((Date.now() - metadata.lastEventTime) < WIP_THRESHOLD_MS) {
         return 'wip';
       }
@@ -962,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()) < 15 * 60 * 1000 || (Date.now() - stats.mtime.getTime()) < 15 * 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
@@ -1033,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;