diff --git a/scripts/quality-gate-local.sh b/scripts/quality-gate-local.sh
index 6624ddc..f3f657a 100755
--- a/scripts/quality-gate-local.sh
+++ b/scripts/quality-gate-local.sh
@@ -45,6 +45,16 @@ calc_cpu_stats() {
 mkdir -p "$(dirname "$BENCH_FILE")"
 : > "$BENCH_FILE"
 
+# The bench file is a synthetic transcript inside the real corpus; without
+# cleanup it shows up in the UI as a project full of "quality gate payload"
+# messages. Remove it (and its directory, if the gate owns it) on every exit
+# so the watcher drops the conversation again.
+cleanup_bench() {
+  rm -f "$BENCH_FILE"
+  rmdir "$(dirname "$BENCH_FILE")" 2>/dev/null || true
+}
+trap cleanup_bench EXIT
+
 log "Building and starting container"
 docker compose up -d --build chat-explorer >/dev/null
 sleep 6
diff --git a/src/analytics-web/chats_mobile.html b/src/analytics-web/chats_mobile.html
index d9623e8..af779dc 100644
--- a/src/analytics-web/chats_mobile.html
+++ b/src/analytics-web/chats_mobile.html
@@ -482,6 +482,30 @@
             margin-right: 6px;
         }
 
+        /* Session-source badges (headless / desktop / worktree agent).
+           Interactive CLI sessions carry no badge. */
+        .source-badge {
+            font-size: 10px;
+            font-weight: 600;
+            letter-spacing: 0.4px;
+            text-transform: uppercase;
+            padding: 2px 6px;
+            border-radius: 4px;
+            margin-right: 6px;
+        }
+        .source-badge.source-headless {
+            color: #b48ede;
+            background: rgba(140, 82, 200, 0.15);
+        }
+        .source-badge.source-desktop {
+            color: #6db3d6;
+            background: rgba(70, 140, 180, 0.15);
+        }
+        .source-badge.source-worktree {
+            color: #d6a86d;
+            background: rgba(180, 130, 60, 0.15);
+        }
+
         /* Subagent count badge */
         .subagent-count {
             font-size: 11px;
@@ -1193,6 +1217,63 @@
             padding-left: 36px;
         }
 
+        /* "Automated runs" cluster: headless SDK sessions outnumber
+           interactive ones inside a project folder, so they collapse behind a
+           sub-header. Deliberately quieter than .project-header - no avatar, no
+           sticky positioning, muted text - so it reads as a divider inside the
+           group rather than a second group. */
+        .cluster-header {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 8px 20px 8px 36px;
+            background: var(--bg-primary);
+            border-bottom: 1px solid var(--border-primary);
+            cursor: pointer;
+            transition: background-color 0.2s ease;
+        }
+
+        .cluster-header:hover {
+            background: var(--bg-secondary);
+        }
+
+        .cluster-label {
+            color: var(--text-secondary);
+            font-size: 0.8rem;
+            font-weight: 600;
+            letter-spacing: 0.04em;
+            text-transform: uppercase;
+        }
+
+        .cluster-count {
+            color: var(--text-secondary);
+            background: var(--bg-tertiary);
+            font-size: 0.75rem;
+            font-weight: 500;
+            padding: 1px 8px;
+            border-radius: 10px;
+        }
+
+        .cluster-toggle {
+            margin-left: auto;
+            color: var(--text-secondary);
+            display: flex;
+            align-items: center;
+        }
+
+        .cluster-toggle-icon {
+            transition: transform 0.2s ease;
+        }
+
+        .cluster-toggle-icon.expanded {
+            transform: rotate(180deg);
+        }
+
+        /* Cluster members sit one level deeper than their sub-header. */
+        .project-group .conversation-item.automated-item {
+            padding-left: 52px;
+        }
+
         .conversation-state {
             font-size: 0.7rem;
             padding: 3px 8px;
@@ -2782,6 +2863,23 @@ <h4 style="margin: 0 0 12px 0; color: var(--text-primary); font-size: 14px;">
     <script src="components/WatcherHealth.js"></script>
 
     <script>
+        /**
+         * The one HTML-escaping implementation for ELEMENT CONTENT. The
+         * ChatsMobileApp method delegates here, and standalone functions
+         * (the analytics modal renders outside the class, where `this` is
+         * not the app) call it directly. Neutralizes & < > via text-node
+         * serialization; NOT sufficient for attribute values (no quote
+         * escaping), use the class's escapeAttr for those.
+         * @param {*} text - Value to escape
+         * @returns {string} Escaped text, always a string
+         */
+        function escapeHtmlText(text) {
+            if (text === null || text === undefined) return '';
+            const div = document.createElement('div');
+            div.textContent = typeof text === 'string' ? text : String(text);
+            return div.innerHTML;
+        }
+
         class ChatsMobileApp {
             constructor() {
                 this.conversations = [];
@@ -3159,6 +3257,12 @@ <h3>No sessions found</h3>
                 if (!this.expandedProjects) {
                     this.expandedProjects = new Set(); // All collapsed by default
                 }
+                // Automated-run clusters, keyed by project name. Separate from
+                // expandedProjects so a project can be open with its cluster
+                // still folded. Collapsed on every page load by design.
+                if (!this.expandedClusters) {
+                    this.expandedClusters = new Set();
+                }
 
                 // Render grouped conversations
                 const today = new Date();
@@ -3167,9 +3271,33 @@ <h3>No sessions found</h3>
                 conversationsList.innerHTML = sortedProjects.map(projectName => {
                     const projectConversations = groupedByProject[projectName].conversations;
                     const isExpanded = this.expandedProjects.has(projectName);
+                    const clusterExpanded = this.expandedClusters.has(projectName);
                     const firstLetter = projectName.charAt(0).toUpperCase();
+
+                    // Split the project's rows into the interactive stream and
+                    // the automated (headless SDK) cluster. Subagent rows are
+                    // NOT a third stream: the server emits each parent
+                    // immediately followed by its children, and splitting them
+                    // out would orphan them from their parent. Each child
+                    // instead follows its parent into whichever stream the
+                    // parent landed in, so subagent rendering and ordering are
+                    // exactly what they were before.
+                    const interactive = [];
+                    const automated = [];
+                    const streamByParentId = new Map();
+                    for (const conv of projectConversations) {
+                        if (conv.isSubagent) {
+                            (streamByParentId.get(conv.parentId) || interactive).push(conv);
+                        } else {
+                            const stream = conv.isHeadless ? automated : interactive;
+                            stream.push(conv);
+                            streamByParentId.set(conv.id, stream);
+                        }
+                    }
+
                     // Count sessions excluding subagents (always, regardless of checkbox)
-                    const sessionCount = projectConversations.filter(c => !c.isSubagent).length;
+                    const sessionCount = interactive.filter(c => !c.isSubagent).length;
+                    const automatedCount = automated.filter(c => !c.isSubagent).length;
                     // Format temporal info
                     const latestActivity = groupedByProject[projectName].latestActivity;
                     const fullDate = this.formatFullDate(latestActivity);
@@ -3180,8 +3308,18 @@ <h3>No sessions found</h3>
                     const isToday = activityDate.getTime() === today.getTime();
                     const todayClass = isToday ? ' today-activity' : '';
 
-                    // Render conversations for this project
-                    const conversationsHTML = projectConversations.map(conv => {
+                    // Element-content vs attribute need different escaping: the
+                    // name is rendered as text AND used in data-project="...".
+                    // Declared before the row/cluster markup below, which reads
+                    // projectNameAttr.
+                    const escapedProjectName = this.escapeHtml(projectName);
+                    const projectNameAttr = this.escapeAttr(projectName);
+
+                    // Render one conversation row. `visible` decides only the
+                    // inline display; the markup (classes, badges, data
+                    // attributes) is identical for interactive and automated
+                    // rows so click delegation and styling stay uniform.
+                    const renderRow = (conv, visible, inCluster) => {
                         const state = states[conv.id] || 'inactive';
                         const stateClass = this.getStateClass(state);
                         const stateLabel = this.getStateLabel(state);
@@ -3199,16 +3337,23 @@ <h3>No sessions found</h3>
                         const subagentCount = (conv.subagentCount && conv.subagentCount > 0)
                             ? `<span class="subagent-count">${conv.subagentCount} subagent${conv.subagentCount > 1 ? 's' : ''}</span>`
                             : '';
+                        // Session-source badge. Labels come from a FIXED map
+                        // keyed on server-derived flags; the raw entrypoint
+                        // string is transcript-controlled and is never
+                        // interpolated into markup. Interactive CLI is the
+                        // norm and gets no badge.
+                        const sourceBadge = this.getSourceBadge(conv);
+                        const clusterClass = inCluster ? ' automated-item' : '';
 
                         return `
-                            <div class="conversation-item${subagentClass}${stubClass}" data-conversation-id="${this.escapeAttr(conv.id)}" style="display: ${isExpanded ? 'flex' : 'none'}">
+                            <div class="conversation-item${subagentClass}${stubClass}${clusterClass}" data-conversation-id="${this.escapeAttr(conv.id)}" style="display: ${visible ? 'flex' : 'none'}">
                                 <div class="conversation-avatar conversation-avatar-small">
                                     ${conversationId.substring(0, 2).toUpperCase()}
                                 </div>
                                 <div class="conversation-content">
                                     <div class="conversation-header">
                                         <div class="conversation-name">Session ${conversationId}</div>
-                                        ${subagentBadge}${subagentCount}
+                                        ${sourceBadge}${subagentBadge}${subagentCount}
                                         <div class="conversation-time">${lastActivity}</div>
                                     </div>
                                     <div class="conversation-meta">
@@ -3218,12 +3363,31 @@ <h3>No sessions found</h3>
                                 </div>
                             </div>
                         `;
-                    }).join('');
+                    };
+
+                    const interactiveHTML = interactive
+                        .map(conv => renderRow(conv, isExpanded, false)).join('');
+
+                    // The cluster sub-header follows the project group's own
+                    // expansion; its members additionally need the cluster
+                    // open. Label and count are static text and a number, so
+                    // nothing transcript-controlled is interpolated here.
+                    const clusterHTML = automated.length > 0
+                        ? `
+                            <div class="cluster-header" data-project="${projectNameAttr}" style="display: ${isExpanded ? 'flex' : 'none'}">
+                                <span class="cluster-label">Automated runs</span>
+                                <span class="cluster-count">${automatedCount}</span>
+                                <span class="cluster-toggle">
+                                    <svg class="cluster-toggle-icon ${clusterExpanded ? 'expanded' : ''}" width="16" height="16" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true">
+                                        <path fill-rule="evenodd" d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" clip-rule="evenodd"/>
+                                    </svg>
+                                </span>
+                            </div>
+                          ` + automated.map(conv => renderRow(conv, isExpanded && clusterExpanded, true)).join('')
+                        : '';
+
+                    const conversationsHTML = interactiveHTML + clusterHTML;
 
-                    // Element-content vs attribute need different escaping: the
-                    // name is rendered as text AND used in data-project="...".
-                    const escapedProjectName = this.escapeHtml(projectName);
-                    const projectNameAttr = this.escapeAttr(projectName);
                     return `
                         <div class="project-group${todayClass}" data-project="${projectNameAttr}">
                             <div class="project-header${todayClass}" data-project="${projectNameAttr}">
@@ -3234,7 +3398,7 @@ <h3>No sessions found</h3>
                                     <div class="project-name">${escapedProjectName}</div>
                                     <div class="project-meta">
                                         <span class="project-date">${fullDate} · ${relativeTime}</span>
-                                        <span class="project-sessions">${sessionCount} session${sessionCount !== 1 ? 's' : ''}</span>
+                                        <span class="project-sessions">${sessionCount} session${sessionCount !== 1 ? 's' : ''}${automatedCount > 0 ? ` · ${automatedCount} automated` : ''}</span>
                                     </div>
                                 </div>
                                 <div class="project-toggle">
@@ -3256,6 +3420,17 @@ <h3>No sessions found</h3>
                     });
                 });
 
+                // Bind automated-cluster toggles. The sub-header is a SIBLING of
+                // .project-header, so the project handler above cannot fire for
+                // it; stopPropagation is belt-and-braces against the group ever
+                // becoming clickable itself.
+                conversationsList.querySelectorAll('.cluster-header').forEach(header => {
+                    header.addEventListener('click', (e) => {
+                        e.stopPropagation();
+                        this.toggleAutomatedCluster(header.dataset.project);
+                    });
+                });
+
                 // Bind conversation click events
                 conversationsList.querySelectorAll('.conversation-item').forEach(item => {
                     item.addEventListener('click', () => {
@@ -3276,6 +3451,21 @@ <h3>No sessions found</h3>
                 this.renderConversations(this.conversations, this.conversationStates);
             }
 
+            /**
+             * Fold/unfold a project's "Automated runs" cluster. Independent of
+             * expandedProjects: a project stays open while its cluster folds.
+             * @param {string} projectName - Group key, from data-project
+             */
+            toggleAutomatedCluster(projectName) {
+                if (this.expandedClusters.has(projectName)) {
+                    this.expandedClusters.delete(projectName);
+                } else {
+                    this.expandedClusters.add(projectName);
+                }
+
+                this.renderConversations(this.conversations, this.conversationStates);
+            }
+
             selectConversation(conversationId) {
                 this.selectedConversationId = conversationId;
                 
@@ -4025,6 +4215,10 @@ <h4>Error loading messages</h4>
                 if (!term) {
                     // If search is empty, collapse all projects and reset
                     this.expandedProjects.clear(); // Close all projects
+                    // Clusters live inside those projects, so they collapse too;
+                    // otherwise a re-render would reopen a cluster under a
+                    // project the user just saw close.
+                    if (this.expandedClusters) this.expandedClusters.clear();
 
                     projectGroups.forEach(group => {
                         group.style.display = 'block';
@@ -4035,6 +4229,11 @@ <h4>Error loading messages</h4>
                             conv.style.display = 'none';
                         });
 
+                        // ...and the automated-run sub-headers with them
+                        group.querySelectorAll('.cluster-header').forEach(header => {
+                            header.style.display = 'none';
+                        });
+
                         // Update toggle icon to collapsed state
                         const toggleIcon = group.querySelector('.toggle-icon');
                         if (toggleIcon) {
@@ -4050,6 +4249,13 @@ <h4>Error loading messages</h4>
                     const projectNameLower = projectName.toLowerCase();
                     const conversations = group.querySelectorAll('.conversation-item');
 
+                    // A filtered list is flat: matches show wherever they live,
+                    // so the cluster sub-header (whose chevron would no longer
+                    // describe what is on screen) steps out of the way.
+                    group.querySelectorAll('.cluster-header').forEach(header => {
+                        header.style.display = 'none';
+                    });
+
                     let hasMatchingConversation = false;
 
                     // Check each conversation in this project
@@ -4717,10 +4923,7 @@ <h3>Search Error</h3>
              * @returns {string} Escaped text, always a string
              */
             escapeHtml(text) {
-                if (text === null || text === undefined) return '';
-                const div = document.createElement('div');
-                div.textContent = typeof text === 'string' ? text : String(text);
-                return div.innerHTML;
+                return escapeHtmlText(text);
             }
 
             /**
@@ -5152,6 +5355,9 @@ <h3>Search Error</h3>
                 if (this.expandedProjects) {
                     this.expandedProjects.clear();
                 }
+                if (this.expandedClusters) {
+                    this.expandedClusters.clear();
+                }
 
                 // Hide search results info
                 searchResultsInfo.classList.remove('active');
@@ -5160,6 +5366,28 @@ <h3>Search Error</h3>
                 await this.loadConversations();
             }
 
+            /**
+             * Session-source badge markup for a list row. Labels are a FIXED
+             * allowlist keyed on server-derived booleans; the raw entrypoint
+             * value is transcript-controlled and never reaches the DOM.
+             * Interactive CLI sessions (the norm) get no badge.
+             * @param {Object} conv - Summary or full conversation row
+             * @returns {string} Badge HTML or ''
+             */
+            getSourceBadge(conv) {
+                if (!conv) return '';
+                if (conv.isWorktreeAgent) {
+                    return '<span class="source-badge source-worktree">worktree agent</span>';
+                }
+                if (conv.isHeadless) {
+                    return '<span class="source-badge source-headless">headless</span>';
+                }
+                if (conv.entrypoint === 'claude-desktop') {
+                    return '<span class="source-badge source-desktop">desktop</span>';
+                }
+                return '';
+            }
+
             getStateLabel(state) {
                 // Handle all possible states from StateCalculator with icons
                 const stateLabels = {
@@ -6085,7 +6313,7 @@ <h3>Search Error</h3>
                             font-family: monospace;
                             color: var(--text-primary);
                         ">
-                            <span>${this.escapeHtml(usage.model)}</span>
+                            <span>${escapeHtmlText(usage.model)}</span>
                             <span style="
                                 padding: 2px 6px;
                                 background: rgba(139, 92, 246, 0.3);
@@ -6113,7 +6341,7 @@ <h3>Search Error</h3>
                         return `
                             <div style="margin-bottom: 10px; padding: 8px; background: rgba(255,255,255,0.03); border-radius: 6px;">
                                 <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">
-                                    <span style="font-size: 13px; font-weight: 600; color: var(--text-primary);">${this.escapeHtml(tool)}</span>
+                                    <span style="font-size: 13px; font-weight: 600; color: var(--text-primary);">${escapeHtmlText(tool)}</span>
                                     <span style="font-size: 12px; color: var(--text-secondary);">${count} calls (${percentage}%)</span>
                                 </div>
                                 <div style="height: 4px; background: rgba(255,255,255,0.1); border-radius: 2px; overflow: hidden;">
@@ -6192,7 +6420,7 @@ <h3>Search Error</h3>
                                     font-size: 12px;
                                     color: var(--text-primary);
                                 ">
-                                    <span>${this.escapeHtml(agent.type)}</span>
+                                    <span>${escapeHtmlText(agent.type)}</span>
                                     <span style="color: var(--text-secondary); font-size: 11px;">×${agent.count}</span>
                                 </span>
                             `;
@@ -6219,7 +6447,7 @@ <h3>Search Error</h3>
                                     font-family: monospace;
                                     color: var(--text-primary);
                                 ">
-                                    <span>${this.escapeHtml(cmd.name)}</span>
+                                    <span>${escapeHtmlText(cmd.name)}</span>
                                     <span style="color: var(--text-secondary); font-size: 11px;">×${cmd.count}</span>
                                 </span>
                             `;
@@ -6245,7 +6473,7 @@ <h3>Search Error</h3>
                                     font-size: 12px;
                                     color: var(--text-primary);
                                 ">
-                                    <span>${this.escapeHtml(skill.name)}</span>
+                                    <span>${escapeHtmlText(skill.name)}</span>
                                     <span style="color: var(--text-secondary); font-size: 11px;">×${skill.count}</span>
                                 </span>
                             `;
diff --git a/src/analytics/core/ToolTaxonomy.js b/src/analytics/core/ToolTaxonomy.js
new file mode 100644
index 0000000..bc21db6
--- /dev/null
+++ b/src/analytics/core/ToolTaxonomy.js
@@ -0,0 +1,71 @@
+/**
+ * ToolTaxonomy - classify tool_use blocks and extract file changes.
+ *
+ * Ported from flight-recorder's Claude adapter (ingest/src/adapters/claude.ts).
+ * Pure functions, no dependencies; both the indexer (write path) and the
+ * database layer (backfill/queries) use this one module so the taxonomy
+ * cannot drift between them.
+ */
+
+/**
+ * Bucket a tool name into a coarse kind, extracting the MCP server name
+ * from the mcp__<server>__<tool> convention.
+ * @param {string} name - Tool name as it appears in the tool_use block
+ * @returns {{kind: string, mcp: ?string}} kind is one of:
+ *   mcp | shell | file_edit | file_read | search | task | web | other
+ */
+function toolKind(name) {
+  if (typeof name !== 'string' || !name) return { kind: 'other', mcp: null };
+  if (name.startsWith('mcp__')) return { kind: 'mcp', mcp: name.split('__')[1] || null };
+  const n = name.toLowerCase();
+  if (['bash', 'exec_command'].includes(n)) return { kind: 'shell', mcp: null };
+  if (['edit', 'write', 'multiedit', 'notebookedit'].includes(n)) return { kind: 'file_edit', mcp: null };
+  if (['read', 'notebookread'].includes(n)) return { kind: 'file_read', mcp: null };
+  if (['grep', 'glob', 'websearch', 'toolsearch'].includes(n)) return { kind: 'search', mcp: null };
+  if (['task', 'agent'].includes(n)) return { kind: 'task', mcp: null };
+  if (['webfetch'].includes(n)) return { kind: 'web', mcp: null };
+  return { kind: 'other', mcp: null };
+}
+
+/** Count newlines-delimited lines in a string ('' and null count as 0). */
+function countLines(s) {
+  return s ? String(s).split('\n').length : 0;
+}
+
+/**
+ * Extract a file change from an Edit/Write/MultiEdit/NotebookEdit tool_use
+ * block. Line counts derive from the old/new strings, so they describe the
+ * requested change, not a post-hoc diff.
+ * @param {string} name - Tool name
+ * @param {Object} input - The tool_use input payload
+ * @returns {?{path: string, change_kind: string, added_lines: number, removed_lines: number}}
+ */
+function fileChangeFromTool(name, input) {
+  if (!input || typeof name !== 'string') return null;
+  const n = name.toLowerCase();
+  if (n === 'write') {
+    if (!input.file_path) return null;
+    return { path: input.file_path, change_kind: 'create', added_lines: countLines(input.content), removed_lines: 0 };
+  }
+  if (n === 'edit') {
+    if (!input.file_path) return null;
+    return { path: input.file_path, change_kind: 'edit', added_lines: countLines(input.new_string), removed_lines: countLines(input.old_string) };
+  }
+  if (n === 'multiedit') {
+    if (!input.file_path || !Array.isArray(input.edits)) return null;
+    let added = 0, removed = 0;
+    for (const e of input.edits) {
+      if (!e || typeof e !== 'object') continue;
+      added += countLines(e.new_string);
+      removed += countLines(e.old_string);
+    }
+    return { path: input.file_path, change_kind: 'edit', added_lines: added, removed_lines: removed };
+  }
+  if (n === 'notebookedit') {
+    if (!input.notebook_path) return null;
+    return { path: input.notebook_path, change_kind: 'edit', added_lines: countLines(input.new_source), removed_lines: 0 };
+  }
+  return null;
+}
+
+module.exports = { toolKind, fileChangeFromTool };
diff --git a/src/analytics/core/WorktreeClassifier.js b/src/analytics/core/WorktreeClassifier.js
new file mode 100644
index 0000000..8518cac
--- /dev/null
+++ b/src/analytics/core/WorktreeClassifier.js
@@ -0,0 +1,44 @@
+/**
+ * WorktreeClassifier - detect agent sessions that ran in isolated git
+ * worktree checkouts.
+ *
+ * Harnesses that give an agent its own worktree (the Agent tool's
+ * isolation mode, Claude Code's EnterWorktree, the Cyrus Linear runner)
+ * start the session with a cwd inside a well-known worktree directory.
+ * The transcript itself carries no parent linkage (isSidechain is false,
+ * parentUuid is null), so the cwd convention is the only reliable signal.
+ * Without it, every worktree shows up as its own fake top-level project.
+ */
+
+const path = require('path');
+
+const PATTERNS = [
+  // <repo>/.worktrees/<name>[/...]: Agent tool / workflow worktree isolation
+  { re: /^(.*)\/\.worktrees\/[^/]+(?:\/|$)/, owner: (m) => path.basename(m[1]) },
+  // <repo>/.claude/worktrees/<name>[/...]: Claude Code EnterWorktree
+  { re: /^(.*)\/\.claude\/worktrees\/[^/]+(?:\/|$)/, owner: (m) => path.basename(m[1]) },
+  // ~/.cyrus/worktrees/<issue>[/...]: Cyrus checkouts carry no repo name in
+  // the path, so they group under a single "cyrus" project.
+  { re: /^.*\/\.cyrus\/worktrees\/[^/]+(?:\/|$)/, owner: () => 'cyrus' },
+];
+
+/**
+ * Classify a session cwd.
+ * @param {?string} cwd - The session's working directory
+ * @returns {?{owningProject: ?string}} null when the cwd is not a recognized
+ *   agent-worktree location; otherwise the project the session belongs to
+ *   (null owningProject means "recognized worktree, owner unknown").
+ */
+function classifyAgentWorktree(cwd) {
+  if (typeof cwd !== 'string' || !cwd) return null;
+  for (const p of PATTERNS) {
+    const m = cwd.match(p.re);
+    if (m) {
+      const owningProject = p.owner(m);
+      return { owningProject: owningProject || null };
+    }
+  }
+  return null;
+}
+
+module.exports = { classifyAgentWorktree };
diff --git a/src/analytics/data/DatabaseBackend.js b/src/analytics/data/DatabaseBackend.js
index 41a8a56..cb1b890 100644
--- a/src/analytics/data/DatabaseBackend.js
+++ b/src/analytics/data/DatabaseBackend.js
@@ -220,6 +220,37 @@ class DatabaseBackend {
     return this.searchService.facets();
   }
 
+  /**
+   * Per-tool and per-kind usage rollups (canonical conversations only).
+   * @returns {{tools: Array, kinds: Array, mcpServers: Array}}
+   */
+  toolStats() {
+    if (!this.db) throw new Error('Database not initialized');
+    const { kinds, mcpServers } = this.db.getToolKindStats();
+    return { tools: this.db.getToolUsageStats(), kinds, mcpServers };
+  }
+
+  /**
+   * Conversations that changed files matching a path substring.
+   * @param {string} pathQuery
+   * @param {number} [limit]
+   * @returns {Array}
+   */
+  fileChanges(pathQuery, limit) {
+    if (!this.db) throw new Error('Database not initialized');
+    return this.db.getConversationsTouchingFile(pathQuery, limit);
+  }
+
+  /**
+   * Tool usage for one conversation (analytics modal shape).
+   * @param {string} conversationId
+   * @returns {Object}
+   */
+  conversationToolUsage(conversationId) {
+    if (!this.db) throw new Error('Database not initialized');
+    return this.db.getConversationToolUsage(conversationId);
+  }
+
   /**
    * Role/tool-granular search (message_fts). Same transformed shape as
    * searchConversationsWithSnippets, plus matchedRole/matchedSeq.
@@ -364,6 +395,12 @@ class DatabaseBackend {
       },
       // Subagent hierarchy fields
       isSubagent: conv.isSubagent || false,
+      // Agent-worktree sessions: subagent-like, but with no parent session
+      // recorded in the transcript. Consumers use this to label them.
+      isWorktreeAgent: conv.isWorktreeAgent || false,
+      // Headless (sdk-*) vs interactive (cli / claude-desktop) invocation.
+      entrypoint: conv.entrypoint || null,
+      isHeadless: conv.isHeadless || false,
       parentId: conv.parentId || null
     };
   }
diff --git a/src/analytics/data/DatabaseManager.js b/src/analytics/data/DatabaseManager.js
index cb6712a..cbfa136 100644
--- a/src/analytics/data/DatabaseManager.js
+++ b/src/analytics/data/DatabaseManager.js
@@ -1,6 +1,8 @@
 const path = require('path');
 const fs = require('fs-extra');
 const chalk = require('chalk');
+const { toolKind } = require('../core/ToolTaxonomy');
+const { classifyAgentWorktree } = require('../core/WorktreeClassifier');
 
 /**
  * Shape of the search index. Bump when the extracted content or the search
@@ -15,8 +17,21 @@ const chalk = require('chalk');
  *       non-indexable `DELETE ... WHERE conversation_id = ?` that full-scanned
  *       the entire index on every indexed file, and stops storing the corpus
  *       twice.
+ *   5 = parse-time enrichment: tool_usage gains tool_kind/mcp_server/
+ *       error_count, file_changes rows are extracted from edit tools, and
+ *       messages carry src_line transcript provenance. Data is produced at
+ *       parse time, so every file must re-index to populate it.
  */
-const CONTENT_VERSION = 4;
+const CONTENT_VERSION = 5;
+
+/**
+ * The canonical-session predicate: aggregates that describe "my conversations"
+ * (counts, per-tool stats, file-change stats) reuse this one fragment so
+ * subagent transcripts and empty sessions cannot silently inflate totals.
+ * List/search paths keep their explicit includeSubagents handling; this is
+ * for rollups only.
+ */
+const CANONICAL_CONVERSATIONS = `is_subagent = 0 AND message_count > 0`;
 
 /**
  * How many files may sit below CONTENT_VERSION before search reports itself
@@ -100,22 +115,46 @@ class DatabaseManager {
           tokens_input INTEGER DEFAULT 0,
           tokens_output INTEGER DEFAULT 0,
           primary_model TEXT,
-          indexed_at INTEGER NOT NULL
+          indexed_at INTEGER NOT NULL,
+          is_worktree_agent INTEGER DEFAULT 0,
+          entrypoint TEXT
         )
       `);
 
-      // Tool usage tracking
+      // Tool usage tracking. tool_kind/mcp_server come from ToolTaxonomy;
+      // error_count is the number of calls whose tool_result carried
+      // is_error, correlated by tool_use_id at parse time.
       this.db.exec(`
         CREATE TABLE IF NOT EXISTS tool_usage (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           conversation_id TEXT NOT NULL,
           tool_name TEXT NOT NULL,
           call_count INTEGER DEFAULT 1,
+          tool_kind TEXT,
+          mcp_server TEXT,
+          error_count INTEGER DEFAULT 0,
           FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE,
           UNIQUE(conversation_id, tool_name)
         )
       `);
 
+      // File changes extracted from Write/Edit/MultiEdit/NotebookEdit
+      // tool_use inputs. src_line is the 1-based transcript line of the
+      // tool_use block, so a change links back to its exact JSONL line.
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS file_changes (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          conversation_id TEXT NOT NULL,
+          seq INTEGER,
+          src_line INTEGER,
+          path TEXT NOT NULL,
+          change_kind TEXT NOT NULL,
+          added_lines INTEGER DEFAULT 0,
+          removed_lines INTEGER DEFAULT 0,
+          FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+        )
+      `);
+
       this._createSearchSchema();
 
       // File tracking table - for incremental indexing
@@ -143,6 +182,8 @@ class DatabaseManager {
         CREATE INDEX IF NOT EXISTS idx_conversations_project ON conversations(project);
         CREATE INDEX IF NOT EXISTS idx_conversations_tokens ON conversations(tokens_total DESC);
         CREATE INDEX IF NOT EXISTS idx_tool_usage_tool ON tool_usage(tool_name);
+        CREATE INDEX IF NOT EXISTS idx_file_changes_path ON file_changes(path);
+        CREATE INDEX IF NOT EXISTS idx_file_changes_conversation ON file_changes(conversation_id);
       `);
     } catch (err) {
       throw new Error(`Database index creation failed: ${err.message}`);
@@ -154,6 +195,9 @@ class DatabaseManager {
     // Migration: Add cwd column for project name resolution
     this._migrateCwdColumn();
 
+    // Migration: v5 enrichment columns on tables that predate them
+    this._migrateEnrichmentColumns();
+
     // Search-schema version. See _migrateFtsContentVersion.
     this._migrateFtsContentVersion();
   }
@@ -187,6 +231,7 @@ class DatabaseManager {
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           conversation_id TEXT NOT NULL,
           seq INTEGER NOT NULL,
+          src_line INTEGER,
           role TEXT,
           tool_name TEXT,
           content TEXT NOT NULL
@@ -352,6 +397,40 @@ class DatabaseManager {
     }
   }
 
+  /**
+   * Add the v5 enrichment columns to databases created before them.
+   * CREATE TABLE IF NOT EXISTS leaves an existing table on its old shape, so
+   * these ALTERs are the upgrade path; new databases already have the columns.
+   * Values populate as files re-index under CONTENT_VERSION 5. Failure here
+   * is fatal for the same reason as the search-schema migration: continuing
+   * would mean upsert statements referencing columns that do not exist.
+   * @private
+   */
+  _migrateEnrichmentColumns() {
+    const addMissing = (table, column, ddl) => {
+      const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
+      if (!cols.some(c => c.name === column)) {
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
+      }
+    };
+    try {
+      addMissing('tool_usage', 'tool_kind', 'TEXT');
+      addMissing('tool_usage', 'mcp_server', 'TEXT');
+      addMissing('tool_usage', 'error_count', 'INTEGER DEFAULT 0');
+      addMissing('conversations', 'is_worktree_agent', 'INTEGER DEFAULT 0');
+      addMissing('conversations', 'entrypoint', 'TEXT');
+      // messages may not exist yet on a pre-v4 database; _migrateFtsContentVersion
+      // rebuilds it (with src_line) in that case.
+      const hasMessages = this.db.prepare(
+        `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'messages'`
+      ).get();
+      if (hasMessages) addMissing('messages', 'src_line', 'INTEGER');
+    } catch (err) {
+      console.error(chalk.red(`❌ Enrichment column migration failed: ${err.message}`));
+      throw err;
+    }
+  }
+
   /**
    * Migrate database to add cwd column for better project name resolution
    * @private
@@ -584,8 +663,8 @@ class DatabaseManager {
       INSERT OR REPLACE INTO conversations (
         id, file_path, filename, project, message_count, file_size,
         last_modified, created, tokens_total, tokens_input, tokens_output,
-        primary_model, indexed_at, is_subagent, parent_id, cwd
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        primary_model, indexed_at, is_subagent, parent_id, cwd, is_worktree_agent, entrypoint
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     // Indexed delete on a real table (see _createSchema for why this replaced
@@ -595,8 +674,8 @@ class DatabaseManager {
     `);
 
     const insertMessage = this.db.prepare(`
-      INSERT INTO messages (conversation_id, seq, role, tool_name, content)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO messages (conversation_id, seq, src_line, role, tool_name, content)
+      VALUES (?, ?, ?, ?, ?, ?)
     `);
 
     // conv_no is allocated once per conversation and never reused, so the
@@ -632,8 +711,19 @@ class DatabaseManager {
     `);
 
     const insertTool = this.db.prepare(`
-      INSERT OR REPLACE INTO tool_usage (conversation_id, tool_name, call_count)
-      VALUES (?, ?, ?)
+      INSERT OR REPLACE INTO tool_usage
+        (conversation_id, tool_name, call_count, tool_kind, mcp_server, error_count)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+
+    const deleteOldFileChanges = this.db.prepare(`
+      DELETE FROM file_changes WHERE conversation_id = ?
+    `);
+
+    const insertFileChange = this.db.prepare(`
+      INSERT INTO file_changes
+        (conversation_id, seq, src_line, path, change_kind, added_lines, removed_lines)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
     `);
 
     const transaction = this.db.transaction(() => {
@@ -654,7 +744,9 @@ class DatabaseManager {
         now,
         conversation.isSubagent ? 1 : 0,
         conversation.parentId || null,
-        conversation.cwd || null
+        conversation.cwd || null,
+        conversation.isWorktreeAgent ? 1 : 0,
+        conversation.entrypoint || null
       );
 
       // Replace this conversation's messages. The delete uses
@@ -669,6 +761,7 @@ class DatabaseManager {
           insertMessage.run(
             conversation.id,
             m.seq ?? seqFallback,
+            m.src_line ?? null,
             m.role || 'unknown',
             m.tool_name || null,
             m.text
@@ -681,7 +774,7 @@ class DatabaseManager {
       // tests, and any path that has not been updated to emit per-message
       // records) still need per-message search to find them.
       if ((!messages || messages.length === 0) && searchableContent && searchableContent.trim()) {
-        insertMessage.run(conversation.id, 0, 'conversation', null, searchableContent);
+        insertMessage.run(conversation.id, 0, null, 'conversation', null, searchableContent);
       }
 
       // Conversation-level index: carries cross-message AND/NEAR matching.
@@ -702,13 +795,33 @@ class DatabaseManager {
         now
       );
 
-      // Update tool usage
+      // Update tool usage. Kind/server derive from the name via ToolTaxonomy;
+      // error counts come from the parse-time tool_use_id correlation and
+      // default to 0 for callers that do not supply them.
       deleteOldTools.run(conversation.id);
       if (conversation.toolUsage && conversation.toolUsage.tools) {
+        const errors = conversation.toolUsage.errors || {};
         for (const [toolName, count] of Object.entries(conversation.toolUsage.tools)) {
-          insertTool.run(conversation.id, toolName, count);
+          const { kind, mcp } = toolKind(toolName);
+          insertTool.run(conversation.id, toolName, count, kind, mcp, errors[toolName] || 0);
         }
       }
+
+      // Replace this conversation's file changes (same replace-in-place shape
+      // as messages/tool_usage: indexed delete, then insert).
+      deleteOldFileChanges.run(conversation.id);
+      for (const fc of (conversation.fileChanges || [])) {
+        if (!fc || !fc.path || !fc.change_kind) continue;
+        insertFileChange.run(
+          conversation.id,
+          fc.seq ?? null,
+          fc.src_line ?? null,
+          fc.path,
+          fc.change_kind,
+          fc.added_lines || 0,
+          fc.removed_lines || 0
+        );
+      }
     });
 
     transaction();
@@ -743,7 +856,7 @@ class DatabaseManager {
       SELECT
         id, file_path, filename, project, message_count, file_size,
         last_modified, created, tokens_total, tokens_input, tokens_output,
-        primary_model, indexed_at, is_subagent, parent_id
+        primary_model, indexed_at, is_subagent, parent_id, is_worktree_agent, entrypoint
       FROM conversations
     `;
 
@@ -797,7 +910,7 @@ class DatabaseManager {
         SELECT
           c.id, c.file_path, c.filename, c.project, c.message_count, c.file_size,
           c.last_modified, c.created, c.tokens_total, c.tokens_input, c.tokens_output,
-          c.primary_model, c.indexed_at, c.is_subagent, c.parent_id,
+          c.primary_model, c.indexed_at, c.is_subagent, c.parent_id, c.is_worktree_agent, c.entrypoint,
           bm25(conversation_fts) as relevance
         FROM conversation_fts
         JOIN conv_seq cs ON cs.conv_no = conversation_fts.rowid
@@ -854,7 +967,7 @@ class DatabaseManager {
         SELECT
           c.id, c.file_path, c.filename, c.project, c.message_count, c.file_size,
           c.last_modified, c.created, c.tokens_total, c.tokens_input, c.tokens_output,
-          c.primary_model, c.indexed_at, c.is_subagent, c.parent_id,
+          c.primary_model, c.indexed_at, c.is_subagent, c.parent_id, c.is_worktree_agent, c.entrypoint,
           bm25(conversation_fts) as relevance
         FROM conversation_fts
         JOIN conv_seq cs ON cs.conv_no = conversation_fts.rowid
@@ -992,7 +1105,7 @@ class DatabaseManager {
         SELECT
           c.id, c.file_path, c.filename, c.project, c.message_count, c.file_size,
           c.last_modified, c.created, c.tokens_total, c.tokens_input, c.tokens_output,
-          c.primary_model, c.indexed_at, c.is_subagent, c.parent_id,
+          c.primary_model, c.indexed_at, c.is_subagent, c.parent_id, c.is_worktree_agent, c.entrypoint,
           bm25(message_fts) AS relevance,
           snippet(message_fts, 4, '{{MATCH}}', '{{/MATCH}}', '...', 20) AS snippet,
           message_fts.role AS matched_role, message_fts.seq AS matched_seq
@@ -1106,19 +1219,104 @@ class DatabaseManager {
   }
 
   /**
-   * Get aggregated tool usage statistics
-   * @returns {Object} Tool usage summary
+   * Get aggregated tool usage statistics, canonical conversations only
+   * (no subagent transcripts, no empty sessions).
+   * @returns {Array<{tool_name, tool_kind, mcp_server, total_calls, total_errors, conversations}>}
    */
   getToolUsageStats() {
     const stmt = this.db.prepare(`
-      SELECT tool_name, SUM(call_count) as total_calls, COUNT(DISTINCT conversation_id) as conversations
-      FROM tool_usage
-      GROUP BY tool_name
+      SELECT t.tool_name, t.tool_kind, t.mcp_server,
+             SUM(t.call_count) as total_calls,
+             SUM(t.error_count) as total_errors,
+             COUNT(DISTINCT t.conversation_id) as conversations
+      FROM tool_usage t
+      JOIN conversations c ON c.id = t.conversation_id
+      WHERE ${CANONICAL_CONVERSATIONS}
+      GROUP BY t.tool_name
       ORDER BY total_calls DESC
     `);
     return stmt.all();
   }
 
+  /**
+   * Tool usage for ONE conversation, shaped for the analytics modal.
+   * @param {string} conversationId
+   * @returns {{totalCalls: number, totalErrors: number, uniqueTools: number,
+   *            breakdown: Object, tools: Array}}
+   */
+  getConversationToolUsage(conversationId) {
+    const rows = this.db.prepare(`
+      SELECT tool_name, call_count, tool_kind, mcp_server, error_count
+      FROM tool_usage WHERE conversation_id = ?
+      ORDER BY call_count DESC
+    `).all(conversationId);
+    const breakdown = {};
+    let totalCalls = 0, totalErrors = 0;
+    for (const r of rows) {
+      breakdown[r.tool_name] = r.call_count;
+      totalCalls += r.call_count;
+      totalErrors += r.error_count || 0;
+    }
+    return { totalCalls, totalErrors, uniqueTools: rows.length, breakdown, tools: rows };
+  }
+
+  /**
+   * Aggregate tool usage by kind (shell / file_edit / file_read / search /
+   * task / web / mcp / other), canonical conversations only. MCP rows also
+   * roll up per server.
+   * @returns {{kinds: Array, mcpServers: Array}}
+   */
+  getToolKindStats() {
+    const kinds = this.db.prepare(`
+      SELECT COALESCE(t.tool_kind, 'other') as tool_kind,
+             SUM(t.call_count) as total_calls,
+             SUM(t.error_count) as total_errors,
+             COUNT(DISTINCT t.conversation_id) as conversations
+      FROM tool_usage t
+      JOIN conversations c ON c.id = t.conversation_id
+      WHERE ${CANONICAL_CONVERSATIONS}
+      GROUP BY COALESCE(t.tool_kind, 'other')
+      ORDER BY total_calls DESC
+    `).all();
+    const mcpServers = this.db.prepare(`
+      SELECT t.mcp_server,
+             SUM(t.call_count) as total_calls,
+             SUM(t.error_count) as total_errors,
+             COUNT(DISTINCT t.conversation_id) as conversations
+      FROM tool_usage t
+      JOIN conversations c ON c.id = t.conversation_id
+      WHERE ${CANONICAL_CONVERSATIONS} AND t.mcp_server IS NOT NULL
+      GROUP BY t.mcp_server
+      ORDER BY total_calls DESC
+    `).all();
+    return { kinds, mcpServers };
+  }
+
+  /**
+   * Conversations that changed a given file, newest first. Substring match on
+   * the stored path (bound as a parameter; % wildcards in the input are
+   * escaped so a query cannot widen itself).
+   * @param {string} pathQuery - Substring of the file path
+   * @param {number} [limit=50]
+   * @returns {Array}
+   */
+  getConversationsTouchingFile(pathQuery, limit = 50) {
+    if (typeof pathQuery !== 'string' || !pathQuery.trim()) return [];
+    const escaped = pathQuery.trim().replace(/[%_\\]/g, ch => `\\${ch}`);
+    return this.db.prepare(`
+      SELECT c.id, c.project, c.last_modified,
+             fc.path, SUM(fc.added_lines) as added_lines,
+             SUM(fc.removed_lines) as removed_lines,
+             COUNT(*) as change_count
+      FROM file_changes fc
+      JOIN conversations c ON c.id = fc.conversation_id
+      WHERE fc.path LIKE ? ESCAPE '\\' AND ${CANONICAL_CONVERSATIONS}
+      GROUP BY c.id, fc.path
+      ORDER BY c.last_modified DESC
+      LIMIT ?
+    `).all(`%${escaped}%`, Math.max(1, Math.min(500, limit)));
+  }
+
   /**
    * Get summary statistics
    * @returns {Object} Summary data
@@ -1251,6 +1449,12 @@ class DatabaseManager {
       },
       indexedAt: new Date(row.indexed_at),
       isSubagent: row.is_subagent === 1,
+      isWorktreeAgent: row.is_worktree_agent === 1,
+      // "sdk-*" entrypoints (sdk-cli = `claude -p`/SDK CLI, sdk-py = Python
+      // SDK) are headless invocations; "cli" and "claude-desktop" are
+      // interactive. The raw value is kept so new entrypoints stay visible.
+      entrypoint: row.entrypoint || null,
+      isHeadless: typeof row.entrypoint === 'string' && row.entrypoint.startsWith('sdk'),
       parentId: row.parent_id || null
     };
   }
@@ -1392,7 +1596,11 @@ class DatabaseManager {
           }
         }
 
-        const canonicalName = path.basename(rootCwd);
+        // Agent-worktree folders must resolve to the OWNING project, not the
+        // worktree directory's own basename, or the fake project name this
+        // classification removes would be reinstated here.
+        const worktree = classifyAgentWorktree(rootCwd);
+        const canonicalName = worktree?.owningProject || path.basename(rootCwd);
         if (!canonicalName) continue;
 
         // Update all conversations in this folder to use the canonical name
@@ -1415,3 +1623,4 @@ class DatabaseManager {
 }
 
 module.exports = DatabaseManager;
+module.exports.CANONICAL_CONVERSATIONS = CANONICAL_CONVERSATIONS;
diff --git a/src/analytics/data/Indexer.js b/src/analytics/data/Indexer.js
index a3481ca..6768a20 100644
--- a/src/analytics/data/Indexer.js
+++ b/src/analytics/data/Indexer.js
@@ -2,6 +2,8 @@ const chalk = require('chalk');
 const fs = require('fs-extra');
 const path = require('path');
 const readline = require('readline');
+const { fileChangeFromTool } = require('../core/ToolTaxonomy');
+const { classifyAgentWorktree } = require('../core/WorktreeClassifier');
 
 // Per-block safety ceiling for FTS content. We no longer truncate at 2000
 // chars (that lost recall vs the on-disk text); the only cap is this generous
@@ -208,6 +210,19 @@ class Indexer {
       project = this._extractProjectFromPath(filePath);
     }
 
+    // Agent worktree sessions (Agent tool isolation, EnterWorktree, Cyrus)
+    // get their own top-level transcript directory keyed by the worktree cwd
+    // and carry no parent linkage, so each one masqueraded as a fake project
+    // in the main list. Classify by cwd: mark as a subagent (every default
+    // list/search/rollup already excludes those) and attribute the session
+    // to the owning repo. parentId stays null: the parent session id is
+    // genuinely not recorded anywhere in the child transcript.
+    const worktree = classifyAgentWorktree(parseResult.cwd);
+    const isWorktreeAgent = !!worktree;
+    if (worktree?.owningProject) {
+      project = worktree.owningProject;
+    }
+
     // Build conversation object
     const conversation = {
       id,
@@ -222,7 +237,10 @@ class Indexer {
       tokenUsage: parseResult.tokenUsage,
       modelInfo: parseResult.modelInfo,
       toolUsage: parseResult.toolUsage,
-      isSubagent,
+      fileChanges: parseResult.fileChanges,
+      isSubagent: isSubagent || isWorktreeAgent,
+      isWorktreeAgent,
+      entrypoint: parseResult.entrypoint,
       parentId
     };
 
@@ -240,15 +258,22 @@ class Indexer {
         messageCount: 0,
         tokenUsage: { total: 0, input: 0, output: 0 },
         modelInfo: { primaryModel: null, models: {} },
-        toolUsage: { total: 0, tools: {} },
+        toolUsage: { total: 0, tools: {}, errors: {} },
+        fileChanges: [],  // extracted from edit-tool inputs (ToolTaxonomy)
         searchableContent: '',
         messages: [],   // per-message records for role/tool-granular FTS
-        cwd: null  // Extract working directory for project name
+        cwd: null,  // Extract working directory for project name
+        entrypoint: null  // "cli" | "claude-desktop" | "sdk-cli" | "sdk-py" | ...
       };
 
       const contentParts = [];
       const messageRecords = [];
+      // tool_use.id -> tool name, so a later tool_result's is_error can be
+      // attributed to the right tool. Correlation is by id, never by array
+      // order: one user message can carry several tool_result blocks.
+      const toolUseNames = new Map();
       let msgSeq = 0;
+      let fcSeq = 0;
       const modelCounts = {};
       let lineCount = 0;
       let parseErrorCount = 0;
@@ -283,6 +308,13 @@ class Indexer {
             }
           }
 
+          // Entrypoint: message records carry how the session was invoked
+          // ("cli" / "claude-desktop" are interactive; "sdk-cli" / "sdk-py"
+          // are headless SDK or `claude -p` invocations). First seen wins.
+          if (!result.entrypoint && item.entrypoint) {
+            result.entrypoint = item.entrypoint;
+          }
+
           // Only count user/assistant messages
           if (item.message && (item.type === 'assistant' || item.type === 'user')) {
             result.messageCount++;
@@ -297,8 +329,10 @@ class Indexer {
 
             // Per-message records (role/tool-granular). text+thinking under the
             // message's own role; tool_use/tool_result as separate 'tool' rows.
+            // src_line is the 1-based transcript line, recorded at parse time
+            // because it cannot be reconstructed later.
             for (const rec of this._extractMessageRecords(item.message.content, item.type)) {
-              messageRecords.push({ seq: msgSeq++, ...rec });
+              messageRecords.push({ seq: msgSeq++, src_line: lineCount, ...rec });
             }
 
             // Track token usage from assistant messages
@@ -314,12 +348,29 @@ class Indexer {
               modelCounts[model] = (modelCounts[model] || 0) + 1;
             }
 
-            // Track tool usage from assistant messages
+            // Track tool usage from assistant messages: counts, the id map
+            // for error correlation, and file changes from edit-tool inputs.
             if (item.type === 'assistant' && item.message.content) {
-              const tools = this._extractToolNames(item.message.content);
-              for (const tool of tools) {
-                result.toolUsage.tools[tool] = (result.toolUsage.tools[tool] || 0) + 1;
+              const blocks = Array.isArray(item.message.content)
+                ? item.message.content : [item.message.content];
+              for (const block of blocks) {
+                if (!block || block.type !== 'tool_use' || !block.name) continue;
+                result.toolUsage.tools[block.name] = (result.toolUsage.tools[block.name] || 0) + 1;
                 result.toolUsage.total++;
+                if (block.id) toolUseNames.set(block.id, block.name);
+                const fc = fileChangeFromTool(block.name, block.input);
+                if (fc) result.fileChanges.push({ seq: fcSeq++, src_line: lineCount, ...fc });
+              }
+            }
+
+            // Attribute tool_result errors to their tool via tool_use_id.
+            if (item.type === 'user' && Array.isArray(item.message.content)) {
+              for (const block of item.message.content) {
+                if (!block || block.type !== 'tool_result' || !block.is_error) continue;
+                const tool = block.tool_use_id ? toolUseNames.get(block.tool_use_id) : null;
+                if (tool) {
+                  result.toolUsage.errors[tool] = (result.toolUsage.errors[tool] || 0) + 1;
+                }
               }
             }
           } else if (item.type === 'system' && typeof item.content === 'string') {
@@ -522,26 +573,6 @@ class Indexer {
     return String(payload);
   }
 
-  /**
-   * Extract tool names from message content
-   * @private
-   */
-  _extractToolNames(content) {
-    const tools = [];
-
-    if (!content) return tools;
-
-    const blocks = Array.isArray(content) ? content : [content];
-
-    for (const block of blocks) {
-      if (block.type === 'tool_use' && block.name) {
-        tools.push(block.name);
-      }
-    }
-
-    return tools;
-  }
-
   /**
    * Extract project name from file path
    * @private
diff --git a/src/chats-mobile.js b/src/chats-mobile.js
index ce51228..a26a30b 100644
--- a/src/chats-mobile.js
+++ b/src/chats-mobile.js
@@ -325,6 +325,9 @@ class ChatsMobile {
             lastModified: c.lastModified,
             messageCount: c.messageCount,
             isSubagent: c.isSubagent,
+            isWorktreeAgent: c.isWorktreeAgent,
+            isHeadless: c.isHeadless,
+            entrypoint: c.entrypoint,
             parentId: c.parentId,
             isStub: c.isStub,
             subagentCount: c.subagentCount,
@@ -625,6 +628,42 @@ class ChatsMobile {
       }
     });
 
+    // Tool-usage rollups: per tool, per kind, per MCP server. Canonical
+    // conversations only (no subagent transcripts, no empty sessions).
+    this.app.get('/api/analytics/tools', (req, res) => {
+      try {
+        if (!(this.useDatabaseBackend && this.databaseBackend.isInitialized)) {
+          return res.status(503).json({ error: 'Database backend not available' });
+        }
+        res.json(this.databaseBackend.toolStats());
+      } catch (error) {
+        console.error('Error serving tool stats:', error);
+        res.status(500).json({ error: 'Internal server error' });
+      }
+    });
+
+    // Which conversations changed a file. ?path= is a substring of the
+    // absolute path as it appeared in the tool input.
+    this.app.get('/api/analytics/file-changes', (req, res) => {
+      try {
+        if (!(this.useDatabaseBackend && this.databaseBackend.isInitialized)) {
+          return res.status(503).json({ error: 'Database backend not available' });
+        }
+        const pathQuery = typeof req.query.path === 'string' ? req.query.path : '';
+        if (!pathQuery.trim()) {
+          return res.status(400).json({ error: 'path query parameter is required' });
+        }
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 50;
+        if (!Number.isInteger(limit) || limit <= 0) {
+          return res.status(400).json({ error: 'limit must be a positive integer' });
+        }
+        res.json({ changes: this.databaseBackend.fileChanges(pathQuery, limit) });
+      } catch (error) {
+        console.error('Error serving file changes:', error);
+        res.status(500).json({ error: 'Internal server error' });
+      }
+    });
+
     // API to search within a specific conversation
     this.app.post('/api/conversations/:id/search', async (req, res) => {
       try {
@@ -987,13 +1026,29 @@ class ChatsMobile {
           return `${seconds}s`;
         };
 
+        // Tool usage: the database is the source of truth. The list rows the
+        // database backend serves carry a zeroed toolUsage placeholder (the
+        // analyzer shape is only populated in file-backed mode), which made
+        // the modal report 0 tools for every conversation.
+        let dbToolUsage = null;
+        if (this.useDatabaseBackend && this.databaseBackend.isInitialized) {
+          try {
+            dbToolUsage = this.databaseBackend.conversationToolUsage(conversationId);
+          } catch (err) {
+            console.warn(`⚠️ Tool usage lookup failed for ${conversationId}: ${err.message}`);
+          }
+        }
+        const effectiveToolCalls = dbToolUsage
+          ? dbToolUsage.totalCalls
+          : (conversation.toolUsage?.totalToolCalls || 0);
+
         // Generate optimization tips based on analytics
         const optimizationTips = [];
 
         if (cacheEfficiency < 20 && cacheTotal > 0) {
           optimizationTips.push('• Low cache efficiency detected. Consider restructuring prompts to maximize cache reuse.');
         }
-        if (conversation.toolUsage?.totalToolCalls > 50) {
+        if (effectiveToolCalls > 50) {
           optimizationTips.push('• High tool usage detected. Review if all tool calls are necessary.');
         }
         if (conversation.tokenUsage?.outputTokens > conversation.tokenUsage?.inputTokens * 2) {
@@ -1017,7 +1072,7 @@ class ChatsMobile {
           // Overview
           messageCount: messages.length,
           totalTokens: conversation.tokenUsage?.total || 0,
-          toolCalls: conversation.toolUsage?.totalToolCalls || 0,
+          toolCalls: effectiveToolCalls,
           cacheEfficiency: `${cacheEfficiency}%`,
 
           // Token breakdown. Source these from the freshly-attributed
@@ -1078,11 +1133,13 @@ class ChatsMobile {
             })()
           },
 
-          // Tool usage
+          // Tool usage (DB-backed when available; see dbToolUsage above)
           toolUsage: {
-            totalCalls: conversation.toolUsage?.totalToolCalls || 0,
-            uniqueTools: conversation.toolUsage?.uniqueTools || 0,
-            breakdown: conversation.toolUsage?.toolStats || {},
+            totalCalls: effectiveToolCalls,
+            totalErrors: dbToolUsage ? dbToolUsage.totalErrors : 0,
+            uniqueTools: dbToolUsage ? dbToolUsage.uniqueTools : (conversation.toolUsage?.uniqueTools || 0),
+            breakdown: dbToolUsage ? dbToolUsage.breakdown : (conversation.toolUsage?.toolStats || {}),
+            tools: dbToolUsage ? dbToolUsage.tools : [],
             timeline: conversation.toolUsage?.toolTimeline || []
           },
 
diff --git a/src/mcp/server.js b/src/mcp/server.js
index 6727c1f..d7f7e8a 100644
--- a/src/mcp/server.js
+++ b/src/mcp/server.js
@@ -35,6 +35,8 @@ function toHit(r) {
     conversationId: r.id,
     project: r.project || null,
     isSubagent: !!r.isSubagent,
+    isWorktreeAgent: !!r.isWorktreeAgent,
+    isHeadless: !!r.isHeadless,
     model: r.modelInfo?.primaryModel || null,
     lastModified: r.lastModified instanceof Date ? r.lastModified.toISOString() : (r.lastModified ?? null),
     snippet: r.snippet || null,
@@ -122,6 +124,8 @@ function buildServer({ search, db, transcriptRoot = null }) {
             conversationId: z.string(),
             project: z.string().nullable(),
             isSubagent: z.boolean(),
+            isWorktreeAgent: z.boolean(),
+            isHeadless: z.boolean(),
             model: z.string().nullable(),
             lastModified: z.string().nullable(),
             snippet: z.string().nullable(),
diff --git a/test/integration/analytics-enrichment.test.js b/test/integration/analytics-enrichment.test.js
new file mode 100644
index 0000000..206d428
--- /dev/null
+++ b/test/integration/analytics-enrichment.test.js
@@ -0,0 +1,208 @@
+/**
+ * Integration tests for the v5 parse-time enrichment: tool taxonomy +
+ * error correlation, file-change extraction, src_line provenance, and the
+ * /api/analytics REST surface over them.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const request = require('supertest');
+const { ChatsMobile } = require('../../src/chats-mobile.js');
+
+describe('v5 enrichment pipeline', () => {
+  let tempHome, app;
+
+  beforeAll(async () => {
+    tempHome = await fs.mkdtemp(path.join(os.tmpdir(), 'chat-explorer-enrich-'));
+    const claudeDir = path.join(tempHome, '.claude');
+    const proj = path.join(claudeDir, 'projects', 'alpha');
+    await fs.ensureDir(proj);
+
+    // A session with: a Bash call that errors, a Bash call that succeeds,
+    // an MCP call, and an Edit that changes a file. Results correlate by
+    // tool_use_id, deliberately out of order relative to the calls.
+    const ts = (s) => new Date(Date.UTC(2026, 0, 1, 12, 0, s)).toISOString();
+    const lines = [
+      { type: 'user', timestamp: ts(0), message: { role: 'user', content: 'please fix the build' }, cwd: '/work/demo' },
+      { type: 'assistant', timestamp: ts(5), message: { role: 'assistant', model: 'claude-opus-4', content: [
+        { type: 'tool_use', id: 'toolu_ok', name: 'Bash', input: { command: 'npm test' } },
+        { type: 'tool_use', id: 'toolu_bad', name: 'Bash', input: { command: 'npm run build' } },
+        { type: 'tool_use', id: 'toolu_mcp', name: 'mcp__exa__web_search_exa', input: { query: 'error ENOENT' } },
+        { type: 'tool_use', id: 'toolu_edit', name: 'Edit', input: {
+          file_path: '/work/demo/src/index.js', old_string: 'a\nb\nc', new_string: 'a\nc' } },
+      ] } },
+      // Results out of order: the error joins by id, never by position.
+      { type: 'user', timestamp: ts(10), message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: 'toolu_bad', content: 'build exploded', is_error: true },
+        { type: 'tool_result', tool_use_id: 'toolu_ok', content: 'all green' },
+        { type: 'tool_result', tool_use_id: 'toolu_mcp', content: 'results...' },
+        { type: 'tool_result', tool_use_id: 'toolu_edit', content: 'ok' },
+      ] } },
+      { type: 'assistant', timestamp: ts(15), message: { role: 'assistant', model: 'claude-opus-4', content: 'fixed the build' } },
+    ];
+    await fs.writeFile(path.join(proj, 'enriched.jsonl'),
+      lines.map(l => JSON.stringify(l)).join('\n') + '\n');
+
+    // An agent that ran in an isolated worktree of the SAME repo, launched
+    // headlessly (`claude -p` / SDK CLI, which stamps entrypoint "sdk-cli").
+    // Claude Code keys the transcript directory off the cwd, so this lands in
+    // its own top-level folder and carries no parent linkage - the cwd is the
+    // only signal that it is not a project of its own.
+    const wtProj = path.join(claudeDir, 'projects', '-work-demo--worktrees-agent-fix-1');
+    await fs.ensureDir(wtProj);
+    const wtCwd = '/work/demo/.worktrees/agent-fix-1';
+    const wtLines = [
+      { type: 'user', timestamp: ts(20), entrypoint: 'sdk-cli', message: { role: 'user', content: 'run the isolated fix' }, cwd: wtCwd },
+      { type: 'assistant', timestamp: ts(25), entrypoint: 'sdk-cli', message: { role: 'assistant', model: 'claude-opus-4', content: [
+        { type: 'tool_use', id: 'toolu_wt', name: 'WorktreeOnlyTool', input: { note: 'unique to the worktree session' } },
+      ] } },
+      { type: 'user', timestamp: ts(30), entrypoint: 'sdk-cli', message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: 'toolu_wt', content: 'done' },
+      ] } },
+      { type: 'assistant', timestamp: ts(35), entrypoint: 'sdk-cli', message: { role: 'assistant', model: 'claude-opus-4', content: 'isolated fix applied' } },
+    ];
+    await fs.writeFile(path.join(wtProj, 'wt-agent.jsonl'),
+      wtLines.map(l => JSON.stringify(l)).join('\n') + '\n');
+
+    process.env.CLAUDE_DB_PATH = path.join(tempHome, 'conversations.db');
+    app = new ChatsMobile({ port: 0, claudeDir, verbose: false });
+    await app.initialize();
+    await app.startServer();
+    if (!app.databaseBackend?.isInitialized) throw new Error('DB backend did not initialise');
+  }, 30000);
+
+  afterAll(async () => {
+    try { if (app) await app.stop(); }
+    finally { delete process.env.CLAUDE_DB_PATH; if (tempHome) await fs.remove(tempHome).catch(() => {}); }
+  }, 30000);
+
+  it('GET /api/analytics/tools reports kinds, MCP servers, and correlated errors', async () => {
+    const res = await request(app.app).get('/api/analytics/tools').expect(200);
+
+    const bash = res.body.tools.find(t => t.tool_name === 'Bash');
+    expect(bash).toBeTruthy();
+    expect(bash.tool_kind).toBe('shell');
+    expect(bash.total_calls).toBe(2);
+    // Exactly one Bash call errored, joined via tool_use_id despite the
+    // results arriving out of order.
+    expect(bash.total_errors).toBe(1);
+
+    const mcp = res.body.tools.find(t => t.tool_name === 'mcp__exa__web_search_exa');
+    expect(mcp.tool_kind).toBe('mcp');
+    expect(mcp.mcp_server).toBe('exa');
+
+    const kindNames = res.body.kinds.map(k => k.tool_kind);
+    expect(kindNames).toEqual(expect.arrayContaining(['shell', 'file_edit', 'mcp']));
+    expect(res.body.mcpServers).toEqual([
+      expect.objectContaining({ mcp_server: 'exa', total_calls: 1 }),
+    ]);
+  });
+
+  it('GET /api/analytics/file-changes finds the conversation that edited a file', async () => {
+    const res = await request(app.app)
+      .get('/api/analytics/file-changes?path=src/index.js').expect(200);
+    expect(res.body.changes).toHaveLength(1);
+    const change = res.body.changes[0];
+    expect(change.path).toBe('/work/demo/src/index.js');
+    expect(change.added_lines).toBe(2);
+    expect(change.removed_lines).toBe(3);
+    expect(change.change_count).toBe(1);
+  });
+
+  it('GET /api/analytics/file-changes validates its inputs', async () => {
+    await request(app.app).get('/api/analytics/file-changes').expect(400);
+    await request(app.app).get('/api/analytics/file-changes?path=x&limit=0').expect(400);
+    await request(app.app).get('/api/analytics/file-changes?path=x&limit=abc').expect(400);
+  });
+
+  it('GET /api/conversations/:id/analytics reports real tool counts from the DB', async () => {
+    // The DB-backed list rows carry a zeroed toolUsage placeholder; the
+    // analytics route must read the tool_usage table instead of echoing it
+    // (the modal showed "Tool Calls 0" for every conversation).
+    const res = await request(app.app).get('/api/conversations/enriched/analytics').expect(200);
+    const analytics = res.body.analytics;
+    expect(analytics.toolCalls).toBe(4);
+    expect(analytics.toolUsage.totalCalls).toBe(4);
+    expect(analytics.toolUsage.uniqueTools).toBe(3);
+    expect(analytics.toolUsage.totalErrors).toBe(1);
+    expect(analytics.toolUsage.breakdown.Bash).toBe(2);
+  });
+
+  describe('agent-worktree session classification', () => {
+    it('hides the worktree session from the default conversation list', async () => {
+      const res = await request(app.app).get('/api/conversations').expect(200);
+      const ids = res.body.conversations.map(c => c.id);
+      expect(ids).toContain('enriched');
+      expect(ids).not.toContain('wt-agent');
+    });
+
+    it('surfaces it under the owning project when subagents are included', async () => {
+      const res = await request(app.app)
+        .get('/api/conversations?includeSubagents=true').expect(200);
+      const wt = res.body.conversations.find(c => c.id === 'wt-agent');
+
+      expect(wt).toBeTruthy();
+      expect(wt.isSubagent).toBe(true);
+      expect(wt.isWorktreeAgent).toBe(true);
+      // Attributed to the repo that owns the worktree, not to the worktree
+      // directory's own basename ("agent-fix-1"), which would be a fake project.
+      expect(wt.project).toBe('demo');
+      // Nothing in the transcript records which session spawned it.
+      expect(wt.parentId).toBeNull();
+
+      // The ordinary session is untouched by the classification.
+      const main = res.body.conversations.find(c => c.id === 'enriched');
+      expect(main.isSubagent).toBe(false);
+      expect(main.isWorktreeAgent).toBe(false);
+    });
+
+    it('keeps the worktree session out of the tool rollups', async () => {
+      const res = await request(app.app).get('/api/analytics/tools').expect(200);
+      const names = res.body.tools.map(t => t.tool_name);
+      // The canonical rollup filter excludes subagents, and a worktree session
+      // is one; its calls would otherwise double-count the parent's work.
+      expect(names).not.toContain('WorktreeOnlyTool');
+      expect(names).toContain('Bash');
+    });
+  });
+
+  describe('headless session classification (entrypoint)', () => {
+    it('marks an sdk-cli session headless and leaves an entrypoint-less one interactive', async () => {
+      const res = await request(app.app)
+        .get('/api/conversations?includeSubagents=true').expect(200);
+
+      const wt = res.body.conversations.find(c => c.id === 'wt-agent');
+      expect(wt.entrypoint).toBe('sdk-cli');
+      expect(wt.isHeadless).toBe(true);
+
+      // Older transcripts predate the field entirely; absence must read as
+      // interactive, not as an unknown/undefined that the UI has to guess at.
+      const main = res.body.conversations.find(c => c.id === 'enriched');
+      expect(main.entrypoint).toBeNull();
+      expect(main.isHeadless).toBe(false);
+    });
+
+    it('carries the classification flags through the summary projection', async () => {
+      // view=summary hand-picks list-row fields, so a new flag is invisible to
+      // the list view until it is added there.
+      const res = await request(app.app).get('/api/conversations?view=summary').expect(200);
+      expect(res.body.conversations.length).toBeGreaterThan(0);
+      for (const row of res.body.conversations) {
+        expect(row).toHaveProperty('isHeadless');
+        expect(row).toHaveProperty('isWorktreeAgent');
+      }
+    });
+  });
+
+  it('records src_line provenance on indexed messages', () => {
+    const rows = app.databaseBackend.db.db.prepare(
+      `SELECT src_line FROM messages WHERE src_line IS NOT NULL`
+    ).all();
+    // Every per-message record from the fixture carries its transcript line.
+    expect(rows.length).toBeGreaterThan(0);
+    const lines = rows.map(r => r.src_line);
+    expect(Math.min(...lines)).toBeGreaterThanOrEqual(1);
+    expect(Math.max(...lines)).toBeLessThanOrEqual(4);
+  });
+});
diff --git a/test/unit/DatabaseManager.test.js b/test/unit/DatabaseManager.test.js
index 1874d41..6b667d6 100644
--- a/test/unit/DatabaseManager.test.js
+++ b/test/unit/DatabaseManager.test.js
@@ -169,6 +169,50 @@ describe('DatabaseManager', () => {
       expect(readTool.total_calls).toBe(5);
     });
 
+    it('round-trips the agent-worktree flag', () => {
+      // A worktree agent is subagent-like but parentless, so is_worktree_agent
+      // is the only thing that distinguishes it from a spawned subagent.
+      const conv = createMockConversation({
+        id: 'worktree-agent-001',
+        project: 'demo',
+        cwd: '/work/demo/.worktrees/agent-fix-1',
+        isSubagent: true,
+        isWorktreeAgent: true,
+        parentId: null,
+      });
+      db.upsertConversation(conv, 'worktree agent content');
+
+      expect(db.getConversation('worktree-agent-001').isWorktreeAgent).toBe(true);
+
+      const listed = db.getConversations({ includeSubagents: true })
+        .find(c => c.id === 'worktree-agent-001');
+      expect(listed.isWorktreeAgent).toBe(true);
+      expect(listed.parentId).toBeNull();
+
+      // An ordinary conversation reports false, not undefined.
+      db.upsertConversation(createMockConversation({ id: 'plain-001' }), 'plain content');
+      expect(db.getConversation('plain-001').isWorktreeAgent).toBe(false);
+    });
+
+    it('round-trips the entrypoint and derives headlessness from it', () => {
+      db.upsertConversation(createMockConversation({
+        id: 'headless-001',
+        entrypoint: 'sdk-py',
+      }), 'python sdk content');
+      // No entrypoint: pre-field transcripts and interactive CLI sessions both
+      // have to read as interactive rather than unknown.
+      db.upsertConversation(createMockConversation({ id: 'interactive-001' }), 'plain content');
+
+      const byId = Object.fromEntries(
+        db.getConversations({ includeSubagents: true }).map(c => [c.id, c])
+      );
+
+      expect(byId['headless-001'].entrypoint).toBe('sdk-py');
+      expect(byId['headless-001'].isHeadless).toBe(true);
+      expect(byId['interactive-001'].entrypoint).toBeNull();
+      expect(byId['interactive-001'].isHeadless).toBe(false);
+    });
+
     it('handles subagent conversations', () => {
       const conv = createMockConversation({
         id: 'parent-001_agent-1',
@@ -623,7 +667,8 @@ describe('DatabaseManager', () => {
       for (let i = 0; i < 100; i++) put.run(`/backlog-${i}.jsonl`, 1, 2, 3, 0);
       expect(db.hasPendingRebuild()).toBe(true);
 
-      db.db.prepare(`UPDATE file_index SET content_version = 4`).run();
+      const target = db.db.pragma('user_version', { simple: true });
+      db.db.prepare(`UPDATE file_index SET content_version = ?`).run(target);
       expect(db.hasPendingRebuild()).toBe(false);
     });
 
@@ -661,8 +706,8 @@ describe('DatabaseManager', () => {
   });
 
   describe('FTS content version migration', () => {
-    it('initializes a fresh database at the current target version (4)', () => {
-      expect(db.db.pragma('user_version', { simple: true })).toBe(4);
+    it('initializes a fresh database at the current target version (5)', () => {
+      expect(db.db.pragma('user_version', { simple: true })).toBe(5);
     });
 
     it('marks files stale on a bump but KEEPS file_index so a rebuild resumes', () => {
@@ -675,7 +720,7 @@ describe('DatabaseManager', () => {
       // Re-run the migration as a fresh startup would.
       db._migrateFtsContentVersion();
 
-      expect(db.db.pragma('user_version', { simple: true })).toBe(4);
+      expect(db.db.pragma('user_version', { simple: true })).toBe(5);
 
       // The row survives. This is the resume checkpoint: deleting it (the old
       // behaviour) meant an interrupted rebuild restarted from zero, so a bump
@@ -702,4 +747,166 @@ describe('DatabaseManager', () => {
       expect(db.db.prepare(`SELECT COUNT(*) c FROM file_index`).get().c).toBe(1);
     });
   });
+
+  describe('v5 enrichment (tool taxonomy, file changes, src_line)', () => {
+    it('stores tool_kind, mcp_server and error_count on tool_usage rows', () => {
+      const conv = createMockConversation({
+        id: 'enrich-1',
+        toolUsage: {
+          total: 6,
+          tools: { Bash: 3, 'mcp__exa__web_search_exa': 2, Edit: 1 },
+          errors: { Bash: 2 },
+        },
+      });
+      db.upsertConversation(conv, createSearchableContent());
+
+      const rows = db.db.prepare(
+        `SELECT tool_name, tool_kind, mcp_server, call_count, error_count
+         FROM tool_usage WHERE conversation_id = ? ORDER BY tool_name`
+      ).all('enrich-1');
+
+      expect(rows).toEqual([
+        { tool_name: 'Bash', tool_kind: 'shell', mcp_server: null, call_count: 3, error_count: 2 },
+        { tool_name: 'Edit', tool_kind: 'file_edit', mcp_server: null, call_count: 1, error_count: 0 },
+        { tool_name: 'mcp__exa__web_search_exa', tool_kind: 'mcp', mcp_server: 'exa', call_count: 2, error_count: 0 },
+      ]);
+    });
+
+    it('replaces file_changes on re-index instead of accumulating duplicates', () => {
+      const conv = createMockConversation({
+        id: 'enrich-fc',
+        fileChanges: [
+          { seq: 0, src_line: 7, path: '/repo/a.js', change_kind: 'edit', added_lines: 2, removed_lines: 1 },
+          { seq: 1, src_line: 9, path: '/repo/b.js', change_kind: 'create', added_lines: 10, removed_lines: 0 },
+        ],
+      });
+      db.upsertConversation(conv, createSearchableContent());
+      // Re-index with one change: the old rows must not survive.
+      db.upsertConversation({
+        ...conv,
+        fileChanges: [{ seq: 0, src_line: 7, path: '/repo/a.js', change_kind: 'edit', added_lines: 3, removed_lines: 3 }],
+      }, createSearchableContent());
+
+      const rows = db.db.prepare(
+        `SELECT path, change_kind, added_lines, removed_lines, src_line
+         FROM file_changes WHERE conversation_id = ?`
+      ).all('enrich-fc');
+      expect(rows).toEqual([
+        { path: '/repo/a.js', change_kind: 'edit', added_lines: 3, removed_lines: 3, src_line: 7 },
+      ]);
+    });
+
+    it('skips malformed file_change entries instead of writing partial rows', () => {
+      const conv = createMockConversation({
+        id: 'enrich-bad-fc',
+        fileChanges: [null, { path: '', change_kind: 'edit' }, { path: '/ok.js' }],
+      });
+      db.upsertConversation(conv, createSearchableContent());
+      expect(db.db.prepare(
+        `SELECT COUNT(*) c FROM file_changes WHERE conversation_id = ?`
+      ).get('enrich-bad-fc').c).toBe(0);
+    });
+
+    it('stores src_line on message records', () => {
+      const conv = createMockConversation({ id: 'enrich-src' });
+      db.upsertConversation(conv, createSearchableContent(), [
+        { seq: 0, src_line: 12, role: 'user', tool_name: null, text: 'hello there' },
+        { seq: 1, role: 'assistant', tool_name: null, text: 'no line recorded' },
+      ]);
+
+      const rows = db.db.prepare(
+        `SELECT seq, src_line FROM messages WHERE conversation_id = ? ORDER BY seq`
+      ).all('enrich-src');
+      expect(rows).toEqual([
+        { seq: 0, src_line: 12 },
+        { seq: 1, src_line: null },
+      ]);
+    });
+
+    it('getToolUsageStats excludes subagent transcripts and empty sessions (canonical filter)', () => {
+      db.upsertConversation(createMockConversation({
+        id: 'canon-main',
+        messageCount: 5,
+        toolUsage: { total: 2, tools: { Bash: 2 }, errors: { Bash: 1 } },
+      }), createSearchableContent());
+      db.upsertConversation(createMockConversation({
+        id: 'canon-sub',
+        isSubagent: true,
+        parentId: 'canon-main',
+        messageCount: 5,
+        toolUsage: { total: 9, tools: { Bash: 9 }, errors: {} },
+      }), createSearchableContent());
+      db.upsertConversation(createMockConversation({
+        id: 'canon-empty',
+        messageCount: 0,
+        toolUsage: { total: 7, tools: { Bash: 7 }, errors: {} },
+      }), createSearchableContent());
+
+      const stats = db.getToolUsageStats();
+      const bash = stats.find(s => s.tool_name === 'Bash');
+      expect(bash.total_calls).toBe(2);
+      expect(bash.total_errors).toBe(1);
+      expect(bash.conversations).toBe(1);
+    });
+
+    it('getToolKindStats rolls up by kind and by MCP server', () => {
+      db.upsertConversation(createMockConversation({
+        id: 'kinds-1',
+        messageCount: 3,
+        toolUsage: {
+          total: 5,
+          tools: { Bash: 2, Read: 1, 'mcp__linear__save_issue': 2 },
+          errors: { 'mcp__linear__save_issue': 1 },
+        },
+      }), createSearchableContent());
+
+      const { kinds, mcpServers } = db.getToolKindStats();
+      const byKind = Object.fromEntries(kinds.map(k => [k.tool_kind, k.total_calls]));
+      expect(byKind.shell).toBe(2);
+      expect(byKind.file_read).toBe(1);
+      expect(byKind.mcp).toBe(2);
+      expect(mcpServers).toEqual([
+        { mcp_server: 'linear', total_calls: 2, total_errors: 1, conversations: 1 },
+      ]);
+    });
+
+    it('getConversationsTouchingFile matches by substring and treats % literally', () => {
+      db.upsertConversation(createMockConversation({
+        id: 'touch-1',
+        messageCount: 2,
+        fileChanges: [
+          { seq: 0, src_line: 3, path: '/repo/src/App.js', change_kind: 'edit', added_lines: 4, removed_lines: 2 },
+          { seq: 1, src_line: 5, path: '/repo/src/App.js', change_kind: 'edit', added_lines: 1, removed_lines: 1 },
+        ],
+      }), createSearchableContent());
+
+      const hits = db.getConversationsTouchingFile('src/App');
+      expect(hits).toHaveLength(1);
+      expect(hits[0].id).toBe('touch-1');
+      expect(hits[0].change_count).toBe(2);
+      expect(hits[0].added_lines).toBe(5);
+      expect(hits[0].removed_lines).toBe(3);
+
+      // A wildcard in the query must not match everything.
+      expect(db.getConversationsTouchingFile('%')).toEqual([]);
+      expect(db.getConversationsTouchingFile('')).toEqual([]);
+    });
+
+    it('adds enrichment columns to a database created on the old shape', () => {
+      // Simulate a v4-era table without the new columns.
+      db.db.exec(`
+        DROP TABLE tool_usage;
+        CREATE TABLE tool_usage (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          conversation_id TEXT NOT NULL,
+          tool_name TEXT NOT NULL,
+          call_count INTEGER DEFAULT 1,
+          UNIQUE(conversation_id, tool_name)
+        );
+      `);
+      db._migrateEnrichmentColumns();
+      const cols = db.db.prepare(`PRAGMA table_info(tool_usage)`).all().map(c => c.name);
+      expect(cols).toEqual(expect.arrayContaining(['tool_kind', 'mcp_server', 'error_count']));
+    });
+  });
 });
diff --git a/test/unit/Indexer.test.js b/test/unit/Indexer.test.js
index 98fae42..6ba5d81 100644
--- a/test/unit/Indexer.test.js
+++ b/test/unit/Indexer.test.js
@@ -344,49 +344,106 @@ describe('Indexer', () => {
     });
   });
 
-  describe('_extractToolNames()', () => {
-    it('extracts tool names from tool_use blocks', () => {
-      const content = [
-        { type: 'text', text: 'Some text' },
-        { type: 'tool_use', id: 'tool1', name: 'Read', input: {} },
-        { type: 'tool_use', id: 'tool2', name: 'Write', input: {} },
-      ];
-      const result = indexer._extractToolNames(content);
+  describe('tool extraction and v5 enrichment (parse path)', () => {
+    async function writeJsonl(lines) {
+      const p = path.join(projectsDir, `enrich-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`);
+      await fs.writeFile(p, lines.map(l => JSON.stringify(l)).join('\n'));
+      return p;
+    }
+
+    it('counts tool_use blocks, skipping blocks without a name, and handles single-object content', async () => {
+      const p = await writeJsonl([
+        { type: 'assistant', message: { role: 'assistant', content: [
+          { type: 'text', text: 'Some text' },
+          { type: 'tool_use', id: 'tool1', name: 'Read', input: {} },
+          { type: 'tool_use', id: 'tool2', input: {} }, // no name: skipped
+        ] } },
+        { type: 'assistant', message: { role: 'assistant', content: { type: 'tool_use', name: 'Bash', input: {} } } },
+      ]);
+      const result = await indexer._parseJsonlStreaming(p);
 
-      expect(result).toContain('Read');
-      expect(result).toContain('Write');
-      expect(result.length).toBe(2);
+      expect(result.toolUsage.tools).toEqual({ Read: 1, Bash: 1 });
+      expect(result.toolUsage.total).toBe(2);
     });
 
-    it('handles single tool_use object', () => {
-      const content = { type: 'tool_use', name: 'Bash', input: {} };
-      const result = indexer._extractToolNames(content);
+    it('correlates tool_result errors by tool_use_id, not by array order', async () => {
+      const p = await writeJsonl([
+        { type: 'assistant', message: { role: 'assistant', content: [
+          { type: 'tool_use', id: 'toolu_A', name: 'Read', input: {} },
+          { type: 'tool_use', id: 'toolu_B', name: 'Bash', input: { command: 'x' } },
+        ] } },
+        // Results arrive in the opposite order of the calls; only B errored.
+        { type: 'user', message: { role: 'user', content: [
+          { type: 'tool_result', tool_use_id: 'toolu_B', content: 'boom', is_error: true },
+          { type: 'tool_result', tool_use_id: 'toolu_A', content: 'fine' },
+        ] } },
+      ]);
+      const result = await indexer._parseJsonlStreaming(p);
 
-      expect(result).toContain('Bash');
+      expect(result.toolUsage.errors).toEqual({ Bash: 1 });
     });
 
-    it('returns empty array for content without tools', () => {
-      const content = [
-        { type: 'text', text: 'Just text' },
-      ];
-      const result = indexer._extractToolNames(content);
+    it('ignores errors whose tool_use_id matches no known call', async () => {
+      const p = await writeJsonl([
+        { type: 'user', message: { role: 'user', content: [
+          { type: 'tool_result', tool_use_id: 'toolu_ghost', content: 'boom', is_error: true },
+        ] } },
+      ]);
+      const result = await indexer._parseJsonlStreaming(p);
+      expect(result.toolUsage.errors).toEqual({});
+    });
 
-      expect(result).toEqual([]);
+    it('extracts file changes from edit tools with src_line provenance', async () => {
+      const p = await writeJsonl([
+        { type: 'user', message: { role: 'user', content: 'edit please' } },
+        { type: 'assistant', message: { role: 'assistant', content: [
+          { type: 'tool_use', id: 't1', name: 'Edit', input: {
+            file_path: '/repo/a.js', old_string: 'x\ny', new_string: 'x' } },
+          { type: 'tool_use', id: 't2', name: 'Bash', input: { command: 'ls' } },
+        ] } },
+      ]);
+      const result = await indexer._parseJsonlStreaming(p);
+
+      expect(result.fileChanges).toEqual([
+        { seq: 0, src_line: 2, path: '/repo/a.js', change_kind: 'edit', added_lines: 1, removed_lines: 2 },
+      ]);
     });
 
-    it('returns empty array for null content', () => {
-      expect(indexer._extractToolNames(null)).toEqual([]);
-      expect(indexer._extractToolNames(undefined)).toEqual([]);
+    it('stamps message records with their 1-based transcript line', async () => {
+      const p = await writeJsonl([
+        { type: 'user', message: { role: 'user', content: 'first line' } },
+        { type: 'assistant', message: { role: 'assistant', content: 'second line' } },
+      ]);
+      const result = await indexer._parseJsonlStreaming(p);
+
+      expect(result.messages.map(m => m.src_line)).toEqual([1, 2]);
     });
 
-    it('skips tool_use blocks without name', () => {
-      const content = [
-        { type: 'tool_use', id: 'tool1', input: {} },
-        { type: 'tool_use', id: 'tool2', name: 'ValidTool', input: {} },
-      ];
-      const result = indexer._extractToolNames(content);
+    it('captures the entrypoint from message records, first seen winning', async () => {
+      // The field sits on the record, not inside message. A resumed session can
+      // be re-entered from a different entrypoint later in the same transcript;
+      // how the session STARTED is what classifies it, so the first wins.
+      const p = await writeJsonl([
+        { type: 'user', entrypoint: 'sdk-cli', message: { role: 'user', content: 'headless run' } },
+        { type: 'assistant', entrypoint: 'cli', message: { role: 'assistant', content: 'resumed interactively' } },
+      ]);
+      expect((await indexer._parseJsonlStreaming(p)).entrypoint).toBe('sdk-cli');
+    });
 
-      expect(result).toEqual(['ValidTool']);
+    it('skips leading records that carry no entrypoint', async () => {
+      // Transcripts often open with a summary record from context compaction.
+      const p = await writeJsonl([
+        { type: 'summary', summary: 'earlier session' },
+        { type: 'user', entrypoint: 'claude-desktop', message: { role: 'user', content: 'hello' } },
+      ]);
+      expect((await indexer._parseJsonlStreaming(p)).entrypoint).toBe('claude-desktop');
+    });
+
+    it('reports a null entrypoint when the transcript predates the field', async () => {
+      const p = await writeJsonl([
+        { type: 'user', message: { role: 'user', content: 'no entrypoint here' } },
+      ]);
+      expect((await indexer._parseJsonlStreaming(p)).entrypoint).toBeNull();
     });
   });
 
diff --git a/test/unit/ToolTaxonomy.test.js b/test/unit/ToolTaxonomy.test.js
new file mode 100644
index 0000000..4849287
--- /dev/null
+++ b/test/unit/ToolTaxonomy.test.js
@@ -0,0 +1,83 @@
+/**
+ * Unit tests for ToolTaxonomy (ported from flight-recorder's adapter tests).
+ */
+import { describe, it, expect } from 'vitest';
+const { toolKind, fileChangeFromTool } = require('../../src/analytics/core/ToolTaxonomy.js');
+
+describe('toolKind', () => {
+  it('parses the MCP server name from mcp__<server>__<tool>', () => {
+    expect(toolKind('mcp__exa__web_search_exa')).toEqual({ kind: 'mcp', mcp: 'exa' });
+    expect(toolKind('mcp__claude-in-chrome__navigate')).toEqual({ kind: 'mcp', mcp: 'claude-in-chrome' });
+  });
+
+  it('handles a malformed mcp name without a server segment', () => {
+    expect(toolKind('mcp__')).toEqual({ kind: 'mcp', mcp: null });
+  });
+
+  it('buckets the core tools case-insensitively', () => {
+    expect(toolKind('Bash').kind).toBe('shell');
+    expect(toolKind('Edit').kind).toBe('file_edit');
+    expect(toolKind('MultiEdit').kind).toBe('file_edit');
+    expect(toolKind('Write').kind).toBe('file_edit');
+    expect(toolKind('NotebookEdit').kind).toBe('file_edit');
+    expect(toolKind('Read').kind).toBe('file_read');
+    expect(toolKind('Grep').kind).toBe('search');
+    expect(toolKind('Glob').kind).toBe('search');
+    expect(toolKind('WebSearch').kind).toBe('search');
+    expect(toolKind('Task').kind).toBe('task');
+    expect(toolKind('WebFetch').kind).toBe('web');
+  });
+
+  it('falls back to other for unknown and invalid names', () => {
+    expect(toolKind('TodoWrite').kind).toBe('other');
+    expect(toolKind('')).toEqual({ kind: 'other', mcp: null });
+    expect(toolKind(null).kind).toBe('other');
+    expect(toolKind(undefined).kind).toBe('other');
+  });
+});
+
+describe('fileChangeFromTool', () => {
+  it('Write becomes a create with added lines from content', () => {
+    const fc = fileChangeFromTool('Write', { file_path: 'b.ts', content: 'line1\nline2' });
+    expect(fc).toEqual({ path: 'b.ts', change_kind: 'create', added_lines: 2, removed_lines: 0 });
+  });
+
+  it('Edit counts old and new lines; kind is edit, never guessed as create', () => {
+    const fc = fileChangeFromTool('Edit', {
+      file_path: 'src/a.ts', old_string: 'a\nb\nc', new_string: 'a\nb',
+    });
+    expect(fc).toEqual({ path: 'src/a.ts', change_kind: 'edit', added_lines: 2, removed_lines: 3 });
+  });
+
+  it('MultiEdit sums line counts across edits', () => {
+    const fc = fileChangeFromTool('MultiEdit', {
+      file_path: 'src/m.ts',
+      edits: [
+        { old_string: 'x', new_string: 'y\nz' },
+        { old_string: 'p\nq', new_string: 'r' },
+      ],
+    });
+    expect(fc).toEqual({ path: 'src/m.ts', change_kind: 'edit', added_lines: 3, removed_lines: 3 });
+  });
+
+  it('MultiEdit skips malformed entries in the edits array', () => {
+    const fc = fileChangeFromTool('MultiEdit', {
+      file_path: 'src/m.ts',
+      edits: [null, 'junk', { old_string: 'a', new_string: 'b' }],
+    });
+    expect(fc).toEqual({ path: 'src/m.ts', change_kind: 'edit', added_lines: 1, removed_lines: 1 });
+  });
+
+  it('NotebookEdit uses notebook_path and new_source', () => {
+    const fc = fileChangeFromTool('NotebookEdit', { notebook_path: 'n.ipynb', new_source: 'a\nb\nc' });
+    expect(fc).toEqual({ path: 'n.ipynb', change_kind: 'edit', added_lines: 3, removed_lines: 0 });
+  });
+
+  it('returns null when the path is missing, input is absent, or the tool does not edit files', () => {
+    expect(fileChangeFromTool('Write', { content: 'x' })).toBeNull();
+    expect(fileChangeFromTool('Edit', null)).toBeNull();
+    expect(fileChangeFromTool('MultiEdit', { file_path: 'a', edits: 'nope' })).toBeNull();
+    expect(fileChangeFromTool('Bash', { command: 'rm x' })).toBeNull();
+    expect(fileChangeFromTool('Read', { file_path: 'a' })).toBeNull();
+  });
+});
diff --git a/test/unit/WorktreeClassifier.test.js b/test/unit/WorktreeClassifier.test.js
new file mode 100644
index 0000000..a443390
--- /dev/null
+++ b/test/unit/WorktreeClassifier.test.js
@@ -0,0 +1,89 @@
+/**
+ * WorktreeClassifier Unit Tests
+ *
+ * The cwd convention is the only signal that a session ran inside an isolated
+ * agent worktree: the transcript carries no parent linkage. A false positive
+ * silently re-attributes a real top-level project to something else, so the
+ * negative cases matter as much as the positive ones.
+ */
+
+import { describe, it, expect } from 'vitest';
+const { classifyAgentWorktree } = require('../../src/analytics/core/WorktreeClassifier');
+
+describe('classifyAgentWorktree()', () => {
+  describe('<repo>/.worktrees/<name> (Agent tool isolation)', () => {
+    it('attributes the session to the repo that owns the worktree', () => {
+      expect(classifyAgentWorktree('/Users/dev/projects/my-app/.worktrees/agent-fix-1'))
+        .toEqual({ owningProject: 'my-app' });
+    });
+
+    it('classifies a cwd nested below the worktree root', () => {
+      expect(classifyAgentWorktree('/Users/dev/projects/my-app/.worktrees/agent-fix-1/src/api'))
+        .toEqual({ owningProject: 'my-app' });
+    });
+
+    it('handles a repo checked out at a short path', () => {
+      expect(classifyAgentWorktree('/work/demo/.worktrees/x'))
+        .toEqual({ owningProject: 'demo' });
+    });
+  });
+
+  describe('<repo>/.claude/worktrees/<name> (EnterWorktree)', () => {
+    it('attributes the session to the owning repo', () => {
+      expect(classifyAgentWorktree('/Users/dev/projects/my-app/.claude/worktrees/feature-x'))
+        .toEqual({ owningProject: 'my-app' });
+    });
+
+    it('classifies a cwd nested below the worktree root', () => {
+      expect(classifyAgentWorktree('/Users/dev/projects/my-app/.claude/worktrees/feature-x/test/unit'))
+        .toEqual({ owningProject: 'my-app' });
+    });
+  });
+
+  describe('.cyrus/worktrees/<issue> (Cyrus Linear runner)', () => {
+    it('groups every Cyrus checkout under a single "cyrus" project', () => {
+      // The path carries no repo name, so per-issue folders would otherwise
+      // each become their own fake top-level project.
+      expect(classifyAgentWorktree('/Users/dev/.cyrus/worktrees/NAS-1467'))
+        .toEqual({ owningProject: 'cyrus' });
+      expect(classifyAgentWorktree('/Users/dev/.cyrus/worktrees/ENG-42'))
+        .toEqual({ owningProject: 'cyrus' });
+    });
+
+    it('classifies a cwd nested below the issue root', () => {
+      expect(classifyAgentWorktree('/Users/dev/.cyrus/worktrees/NAS-1467/packages/core'))
+        .toEqual({ owningProject: 'cyrus' });
+    });
+  });
+
+  describe('non-worktree cwds', () => {
+    it('does not classify a plain repo checkout', () => {
+      expect(classifyAgentWorktree('/Users/dev/projects/claude-chats-monitor')).toBeNull();
+      expect(classifyAgentWorktree('/work/demo')).toBeNull();
+      expect(classifyAgentWorktree('/work/demo/src/analytics')).toBeNull();
+    });
+
+    it('does not classify a manually-named sibling checkout', () => {
+      // A hand-made clone like `<project>-dev` is a real project of its own.
+      expect(classifyAgentWorktree('/Users/x/dev/projects/claude-chats-monitor-dev')).toBeNull();
+    });
+
+    it('does not classify a directory that merely contains "worktrees"', () => {
+      expect(classifyAgentWorktree('/Users/x/worktrees-collection/thing')).toBeNull();
+      expect(classifyAgentWorktree('/Users/x/worktrees/thing')).toBeNull();
+      expect(classifyAgentWorktree('/Users/x/my.worktrees-backup/thing')).toBeNull();
+    });
+
+    it('does not classify the worktrees container itself, only a checkout inside it', () => {
+      expect(classifyAgentWorktree('/work/demo/.worktrees')).toBeNull();
+      expect(classifyAgentWorktree('/work/demo/.claude/worktrees')).toBeNull();
+    });
+
+    it('returns null for missing or empty input', () => {
+      expect(classifyAgentWorktree(null)).toBeNull();
+      expect(classifyAgentWorktree(undefined)).toBeNull();
+      expect(classifyAgentWorktree('')).toBeNull();
+      expect(classifyAgentWorktree(12345)).toBeNull();
+    });
+  });
+});