@qiaolei81/copilot-session-viewer 0.2.6 → 0.3.0

package/CHANGELOG.md

@@ -5,6 +5,70 @@ 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.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
+- **304 Caching on Live Sessions** - Disabled ETag on events API (`Cache-Control: no-store`) so active/WIP sessions always return fresh data on page refresh
+- **Updated Time Inaccuracy** - Session detail page now shows last event timestamp as "Updated" time instead of file mtime
+- **E2E CI Stability** - `#loading-indicator` is always in DOM regardless of session count; removed conditional session count check that caused false negatives
+
+## [0.2.5] - 2026-03-04
+
+### Fixed
+- **Flaky Unit Tests** - Upload directory now isolated per test via `UPLOAD_DIR` env var to prevent cross-test pollution
+- **Timing Variance in Tests** - `ageMs` threshold relaxed from `>= 0` to `>= -100` to tolerate clock precision on fast CI runners
+
+## [0.2.4] - 2026-03-04
+
+### Fixed
+- **E2E Skip on Empty Environment** - Tests now skip gracefully when no sessions exist in CI (no `~/.copilot/session-state/` data)
+- **VSCode Filter Pill** - Temporarily hidden in UI (feature in progress)
+
+## [0.2.3] - 2026-03-04
+
+### Fixed
+- **Lint Errors** - Fixed unused variable warnings in `vscode-parser.js` (`canParse`, `agentName`, `itemIdx`) and `sessionRepository.js` (unused `VsCodeParser` import)
+- **Stale Unit Tests** - Updated test expectations to match current API signatures (`getPaginatedSessions(1, 20, "copilot")`)
+
 ## [0.2.2] - 2026-02-27
 
 ### Fixed
@@ -190,6 +254,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - CORS restricted to localhost
 - File upload size limits (50MB)
 
+[0.2.6]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.2.6
+[0.2.5]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.2.5
+[0.2.4]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.2.4
+[0.2.3]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.2.3
 [0.1.7]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.1.7
 [0.1.6]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.1.6
 [0.1.3]: https://github.com/qiaolei81/copilot-session-viewer/releases/tag/v0.1.3

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,
           },
         });
       };
@@ -230,9 +354,15 @@ class VsCodeParser extends BaseSessionParser {
 
           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) {
@@ -296,49 +426,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;
+
+      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; }
 
-      // Try invocationMessage text for agent file path
+      // 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 +491,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.6",
+  "version": "0.3.0",
   "description": "Web UI for viewing GitHub Copilot CLI session logs",
   "author": "Lei Qiao <qiaolei81@gmail.com>",
   "license": "MIT",

package/src/app.js

@@ -15,6 +15,7 @@ const { requestTimeout, developmentCors, errorHandler, notFoundHandler } = requi
 const SessionController = require('./controllers/sessionController');
 const InsightController = require('./controllers/insightController');
 const UploadController = require('./controllers/uploadController');
+const TagController = require('./controllers/tagController');
 
 function createApp(options = {}) {
   const app = express();
@@ -26,6 +27,7 @@ function createApp(options = {}) {
   const sessionController = new SessionController(options.sessionService);
   const insightController = new InsightController(options.insightService, options.sessionService);
   const uploadController = new UploadController();
+  const tagController = new TagController(options.tagService);
 
   // Minimal security headers for local development tool
   // Custom CSP without upgrade-insecure-requests
@@ -96,6 +98,11 @@ function createApp(options = {}) {
   app.get('/api/sessions/:id/events', sessionController.getSessionEvents.bind(sessionController));
   app.get('/api/sessions/:id/timeline', sessionController.getTimeline.bind(sessionController));
 
+  // Tag routes
+  app.get('/api/tags', tagController.getAllTags.bind(tagController));
+  app.get('/api/sessions/:id/tags', tagController.getSessionTags.bind(tagController));
+  app.put('/api/sessions/:id/tags', tagController.setSessionTags.bind(tagController));
+
   // Upload routes
   app.get('/session/:id/share', uploadController.shareSession.bind(uploadController));
   app.post('/session/import',

package/src/controllers/sessionController.js

@@ -15,11 +15,29 @@ class SessionController {
       // Only load default pill (copilot) first 20 sessions
       const paginationData = await this.sessionService.getPaginatedSessions(1, 20, 'copilot');
 
+      // Build source path hints from repository config
+      const sourceHints = {};
+      if (this.sessionService.sessionRepository && this.sessionService.sessionRepository.sources) {
+        for (const src of this.sessionService.sessionRepository.sources) {
+          // Replace home dir with ~ for display
+          const home = require('os').homedir();
+          let displayPath = src.dir;
+          if (displayPath.startsWith(home)) {
+            displayPath = '~' + displayPath.slice(home.length);
+          }
+          // Normalize path separators for display
+          displayPath = displayPath.replace(/\\/g, '/');
+          if (!displayPath.endsWith('/')) displayPath += '/';
+          sourceHints[src.type] = displayPath;
+        }
+      }
+
       // Pass data for infinite scroll
       const templateData = {
         sessions: paginationData.sessions,
         hasMore: paginationData.hasNextPage,
-        totalSessions: paginationData.totalSessions
+        totalSessions: paginationData.totalSessions,
+        sourceHints: JSON.stringify(sourceHints)
       };
 
       res.render('index', templateData);