claude-slim 2.6.0 → 2.7.0

package/dist/scanner/index.js

@@ -7,9 +7,11 @@ import { scanPluginSkills } from './plugin-skills.js';
 import { scanMemoryFiles } from './memory.js';
 import { scanMcpServers } from './mcp.js';
 import { parseClaudeMdSections } from './claude-md.js';
-import { getDisabledPlugins } from './disabled-plugins.js';
+import { getDisabledPlugins, getInstalledPlugins } from './disabled-plugins.js';
 import { scanSessionUsage } from './sessions.js';
 import { classifyIssues } from './detectors.js';
+import { scanPluginSurfaces } from './plugin-surfaces.js';
+import { computePluginBreakdown } from './plugin-breakdown.js';
 import { SKILL_PROMPT_OVERHEAD_TOKENS } from './constants.js';
 const DEFAULT_LOOKBACK_DAYS = 60;
 export async function scan(opts = {}) {
@@ -22,10 +24,19 @@ export async function scan(opts = {}) {
         getDisabledPlugins(),
         scanSessionUsage(lookbackDays),
     ]);
+    const pluginSurfaces = scanPluginSurfaces();
     // Annotate plugin status
     for (const plugin of plugins) {
         plugin.status = disabledPlugins.has(plugin.name) ? 'disabled' : 'enabled';
     }
+    // Build enabled plugin list for unused_plugin detector. `plugins[].name` from
+    // existing code is the marketplace name (intentional, for cache-dir matching).
+    // For unused_plugin we need the actual plugin name parsed from
+    // `claude plugin list` output (the `<plugin>` part of `<plugin>@<marketplace>`).
+    const installed = await getInstalledPlugins();
+    const enabledPlugins = installed
+        .filter((p) => p.enabled)
+        .map((p) => ({ name: p.name, marketplace: p.marketplace }));
     // CLAUDE.md
     const claudeMdContent = await safeReadFile(join(getClaudeDir(), 'CLAUDE.md'));
     const claudeMdBytes = claudeMdContent ? Buffer.byteLength(claudeMdContent) : 0;
@@ -40,6 +51,23 @@ export async function scan(opts = {}) {
         recentSkillInvocations: sessionUsage.invokedSkills,
         sessionDataAvailable: sessionUsage.dataAvailable,
         lookbackDays,
+        pluginSurfaces,
+        enabledPlugins,
+        recentMcpPrefixes: sessionUsage.mcpPrefixesInvoked,
+        recentCommands: sessionUsage.commandsInvoked,
+        totalUserCallableInvocations: sessionUsage.totalUserCallableInvocations,
+        sessionsInWindow: sessionUsage.sessionsInWindow,
+    });
+    // Compute plugin breakdown (used by PLUGINS table in scan output)
+    const pluginBreakdown = computePluginBreakdown({
+        surfaces: pluginSurfaces,
+        installedPlugins: installed,
+        invokedSkills: sessionUsage.invokedSkills,
+        mcpPrefixesInvoked: sessionUsage.mcpPrefixesInvoked,
+        commandsInvoked: sessionUsage.commandsInvoked,
+        totalUserCallableInvocations: sessionUsage.totalUserCallableInvocations,
+        sessionsInWindow: sessionUsage.sessionsInWindow,
+        claudeMdSections,
     });
     // Estimate total tokens at startup
     const skillListingTokens = (localSkills.length + pluginSkills.length) * SKILL_PROMPT_OVERHEAD_TOKENS;
@@ -58,5 +86,6 @@ export async function scan(opts = {}) {
         mcpServerNames: mcp.names,
         issues,
         totalTokensBefore,
+        pluginBreakdown,
     };
 }

package/dist/scanner/plugin-breakdown.d.ts

@@ -0,0 +1,16 @@
+import type { PluginBreakdown } from '../types.js';
+import type { PluginSurfaces } from './plugin-surfaces.js';
+import type { InstalledPlugin } from './disabled-plugins.js';
+import type { ClaudeMdSection } from './plugin-cost.js';
+export interface PluginBreakdownOptions {
+    surfaces: PluginSurfaces[];
+    installedPlugins: InstalledPlugin[];
+    invokedSkills: Set<string>;
+    mcpPrefixesInvoked: Set<string>;
+    commandsInvoked: Set<string>;
+    totalUserCallableInvocations: number;
+    sessionsInWindow: number;
+    claudeMdSections: ClaudeMdSection[];
+}
+export declare function computePluginBreakdown(opts: PluginBreakdownOptions): PluginBreakdown[];
+export declare function formatPluginsTable(rows: PluginBreakdown[], totalInstalled: number, totalEnabled: number): string;

package/dist/scanner/plugin-breakdown.js

@@ -0,0 +1,129 @@
+import { computePluginCosts } from './plugin-cost.js';
+const MIN_SESSIONS = 3;
+function classifyStatus(opts) {
+    const { surface, enabled, invokedSkills, mcpPrefixesInvoked, commandsInvoked, totalUserCallableInvocations, sessionsInWindow } = opts;
+    if (!enabled)
+        return 'disabled';
+    if (!surface)
+        return 'insufficient data';
+    const userCallableSurfaces = surface.skills.length + surface.mcpServerKeys.length + surface.commands.length;
+    if (userCallableSurfaces === 0)
+        return 'agent-only';
+    // Suppression: not enough session data
+    if (sessionsInWindow < MIN_SESSIONS || totalUserCallableInvocations === 0) {
+        return 'insufficient data';
+    }
+    // Check if any surface was actually invoked
+    const skillUsed = surface.skills.some((s) => {
+        // Skills may be invoked as <pluginName>:<skillName> or just <skillName>
+        return (invokedSkills.has(`${surface.pluginName}:${s}`) ||
+            invokedSkills.has(s));
+    });
+    const mcpUsed = surface.mcpToolPrefixes.some((p) => mcpPrefixesInvoked.has(p));
+    const cmdUsed = surface.commands.some((c) => commandsInvoked.has(c));
+    if (skillUsed || mcpUsed || cmdUsed)
+        return 'used';
+    return 'unused';
+}
+export function computePluginBreakdown(opts) {
+    const { surfaces, installedPlugins, invokedSkills, mcpPrefixesInvoked, commandsInvoked, totalUserCallableInvocations, sessionsInWindow, claudeMdSections, } = opts;
+    // Build map: pluginName → surface
+    const surfaceMap = new Map();
+    for (const s of surfaces) {
+        // Prefer the most recently installed version (largest installedAt)
+        const existing = surfaceMap.get(s.pluginName);
+        if (!existing || s.installedAt > existing.installedAt) {
+            surfaceMap.set(s.pluginName, s);
+        }
+    }
+    // Build cost map: pluginName → tokens
+    const costs = computePluginCosts(surfaces, claudeMdSections);
+    const costMap = new Map();
+    for (const c of costs) {
+        const existing = costMap.get(c.pluginName) ?? 0;
+        costMap.set(c.pluginName, existing + c.totalEstimatedTokens);
+    }
+    // Collect all unique plugin names from both installed list and surfaces.
+    // Skip noise from failed plugin installs: cache dirs like `temp_git_*` get
+    // walked as if they were marketplaces, surfacing `.git/{hooks,info,...}` as
+    // fake "plugins". The temp_cache detector already flags these for cleanup.
+    const isNoise = (pluginName, marketplace) => pluginName === '.git' || marketplace.startsWith('temp_git_');
+    const allNames = new Set();
+    for (const p of installedPlugins) {
+        if (!isNoise(p.name, p.marketplace))
+            allNames.add(p.name);
+    }
+    for (const s of surfaces) {
+        if (!isNoise(s.pluginName, s.marketplace))
+            allNames.add(s.pluginName);
+    }
+    const rows = [];
+    for (const name of allNames) {
+        const installed = installedPlugins.find((p) => p.name === name);
+        const enabled = installed ? installed.enabled : true; // surfaces not in list are treated as enabled
+        const marketplace = installed?.marketplace ?? surfaceMap.get(name)?.marketplace ?? '';
+        const surface = surfaceMap.get(name);
+        const status = classifyStatus({
+            surface,
+            enabled,
+            invokedSkills,
+            mcpPrefixesInvoked,
+            commandsInvoked,
+            totalUserCallableInvocations,
+            sessionsInWindow,
+        });
+        const lastUsed = status === 'used' ? 'used' : 'never';
+        rows.push({
+            name,
+            marketplace,
+            tokens: costMap.get(name) ?? 0,
+            skills: surface?.skills.length ?? 0,
+            mcp: surface?.mcpServerKeys.length ?? 0,
+            commands: surface?.commands.length ?? 0,
+            lastUsed,
+            status,
+        });
+    }
+    // Sort by tokens descending
+    rows.sort((a, b) => b.tokens - a.tokens);
+    return rows;
+}
+export function formatPluginsTable(rows, totalInstalled, totalEnabled) {
+    const lines = [];
+    lines.push('');
+    lines.push(`\x1b[1m  PLUGIN BREAKDOWN\x1b[0m (${totalInstalled} installed, ${totalEnabled} enabled)`);
+    if (rows.length === 0) {
+        lines.push('    (none)');
+        return lines.join('\n');
+    }
+    // Column widths: Plugin(30) ~Tokens(10) Skills(7) MCP(5) Cmd(5) Last used(11) Status(20)
+    const COL_PLUGIN = 30;
+    const COL_TOKENS = 10;
+    const COL_SKILLS = 7;
+    const COL_MCP = 5;
+    const COL_CMD = 5;
+    const COL_LAST = 11;
+    // Status: flexible (rest of line)
+    const rpad = (s, n) => s.padEnd(n);
+    const lpad = (s, n) => s.padStart(n);
+    const header = `    ${rpad('Plugin', COL_PLUGIN)}` +
+        `${lpad('~Tokens', COL_TOKENS)}` +
+        `${lpad('Skills', COL_SKILLS)}` +
+        `${lpad('MCP', COL_MCP)}` +
+        `${lpad('Cmd', COL_CMD)}` +
+        `  ${'Last used'.padEnd(COL_LAST)}` +
+        `Status`;
+    lines.push(header);
+    for (const row of rows) {
+        const tokStr = row.tokens > 0 ? `~${row.tokens.toLocaleString()}` : '~?';
+        const line = `    ${rpad(row.name, COL_PLUGIN)}` +
+            `${lpad(tokStr, COL_TOKENS)}` +
+            `${lpad(String(row.skills), COL_SKILLS)}` +
+            `${lpad(String(row.mcp), COL_MCP)}` +
+            `${lpad(String(row.commands), COL_CMD)}` +
+            `  ${row.lastUsed.padEnd(COL_LAST)}` +
+            `${row.status}`;
+        lines.push(line);
+    }
+    return lines.join('\n');
+}

package/dist/scanner/plugin-cost.d.ts

@@ -0,0 +1,27 @@
+import type { PluginSurfaces } from './plugin-surfaces.js';
+export interface PluginCostBreakdown {
+    pluginName: string;
+    marketplace: string;
+    /** Tokens from the matching CLAUDE.md section (0 if no match). */
+    claudeMdTokens: number;
+    /** SKILL_PROMPT_OVERHEAD_TOKENS × skills.length */
+    skillTokens: number;
+    /** DEFERRED_TOOL_OVERHEAD_TOKENS × MCP_SERVER_TOOLS_AVG × mcpServerKeys.length */
+    mcpToolTokens: number;
+    /** COMMAND_OVERHEAD_TOKENS × commands.length */
+    commandTokens: number;
+    /** Sum of all fields above. All values are estimates (~). */
+    totalEstimatedTokens: number;
+}
+export interface ClaudeMdSection {
+    name: string;
+    sizeBytes: number;
+    tokens: number;
+}
+/**
+ * Compute estimated system-prompt token cost for each plugin.
+ *
+ * All returned token counts are estimates (±20%). Callers should surface
+ * them with a `~` prefix in any UI output.
+ */
+export declare function computePluginCosts(surfaces: PluginSurfaces[], claudeMdSections: ClaudeMdSection[]): PluginCostBreakdown[];

package/dist/scanner/plugin-cost.js

@@ -0,0 +1,35 @@
+import { SKILL_PROMPT_OVERHEAD_TOKENS, DEFERRED_TOOL_OVERHEAD_TOKENS, COMMAND_OVERHEAD_TOKENS, MCP_SERVER_TOOLS_AVG, } from './constants.js';
+/**
+ * Find a CLAUDE.md section whose name contains the plugin name as a substring
+ * (case-insensitive). Returns the first match or null.
+ * Fuzzy matching is intentionally disabled to avoid false positives.
+ */
+function matchSection(pluginName, sections) {
+    const lower = pluginName.toLowerCase();
+    return sections.find((s) => s.name.toLowerCase().includes(lower)) ?? null;
+}
+/**
+ * Compute estimated system-prompt token cost for each plugin.
+ *
+ * All returned token counts are estimates (±20%). Callers should surface
+ * them with a `~` prefix in any UI output.
+ */
+export function computePluginCosts(surfaces, claudeMdSections) {
+    return surfaces.map((s) => {
+        const matched = matchSection(s.pluginName, claudeMdSections);
+        const claudeMdTokens = matched?.tokens ?? 0;
+        const skillTokens = SKILL_PROMPT_OVERHEAD_TOKENS * s.skills.length;
+        const mcpToolTokens = DEFERRED_TOOL_OVERHEAD_TOKENS * MCP_SERVER_TOOLS_AVG * s.mcpServerKeys.length;
+        const commandTokens = COMMAND_OVERHEAD_TOKENS * s.commands.length;
+        const totalEstimatedTokens = claudeMdTokens + skillTokens + mcpToolTokens + commandTokens;
+        return {
+            pluginName: s.pluginName,
+            marketplace: s.marketplace,
+            claudeMdTokens,
+            skillTokens,
+            mcpToolTokens,
+            commandTokens,
+            totalEstimatedTokens,
+        };
+    });
+}

package/dist/scanner/plugin-surfaces.d.ts

@@ -0,0 +1,14 @@
+export interface PluginSurfaces {
+    pluginName: string;
+    marketplace: string;
+    version: string;
+    installDir: string;
+    installedAt: number;
+    skills: string[];
+    mcpServerKeys: string[];
+    mcpToolPrefixes: string[];
+    commands: string[];
+    agentCount: number;
+    hookCount: number;
+}
+export declare function scanPluginSurfaces(): PluginSurfaces[];

package/dist/scanner/plugin-surfaces.js

@@ -0,0 +1,129 @@
+import { join } from 'node:path';
+import { statSync } from 'node:fs';
+import { readFileSync, readdirSync } from 'node:fs';
+import { getPluginsDir } from '../paths.js';
+function safeReaddir(p) {
+    try {
+        return readdirSync(p);
+    }
+    catch {
+        return [];
+    }
+}
+function safeStat(p) {
+    try {
+        return statSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+function isDir(p) {
+    const s = safeStat(p);
+    return s != null && s.isDirectory();
+}
+function isFile(p) {
+    const s = safeStat(p);
+    return s != null && s.isFile();
+}
+function parseMcpServerKeys(installDir) {
+    const mcpPath = join(installDir, '.mcp.json');
+    if (!isFile(mcpPath))
+        return [];
+    try {
+        const raw = readFileSync(mcpPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' &&
+            parsed !== null &&
+            'mcpServers' in parsed &&
+            typeof parsed.mcpServers === 'object' &&
+            parsed.mcpServers !== null) {
+            return Object.keys(parsed.mcpServers);
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function scanSkills(installDir) {
+    const skillsDir = join(installDir, 'skills');
+    if (!isDir(skillsDir))
+        return [];
+    const names = [];
+    for (const entry of safeReaddir(skillsDir)) {
+        const skillDir = join(skillsDir, entry);
+        if (!isDir(skillDir))
+            continue;
+        const upper = join(skillDir, 'SKILL.md');
+        const lower = join(skillDir, 'skill.md');
+        if (isFile(upper) || isFile(lower)) {
+            names.push(entry);
+        }
+    }
+    return names;
+}
+function scanCommands(installDir) {
+    const commandsDir = join(installDir, 'commands');
+    if (!isDir(commandsDir))
+        return [];
+    const names = [];
+    for (const entry of safeReaddir(commandsDir)) {
+        if (entry.endsWith('.md') && isFile(join(commandsDir, entry))) {
+            names.push(entry.slice(0, -3)); // strip .md
+        }
+    }
+    return names;
+}
+function countFiles(dir) {
+    if (!isDir(dir))
+        return 0;
+    let count = 0;
+    for (const entry of safeReaddir(dir)) {
+        if (isFile(join(dir, entry)))
+            count++;
+    }
+    return count;
+}
+export function scanPluginSurfaces() {
+    const pluginsDir = getPluginsDir();
+    const results = [];
+    for (const marketplace of safeReaddir(pluginsDir)) {
+        const marketplaceDir = join(pluginsDir, marketplace);
+        if (!isDir(marketplaceDir))
+            continue;
+        for (const pluginName of safeReaddir(marketplaceDir)) {
+            const pluginBaseDir = join(marketplaceDir, pluginName);
+            if (!isDir(pluginBaseDir))
+                continue;
+            // Each plugin may have version subdirectories
+            for (const version of safeReaddir(pluginBaseDir)) {
+                const installDir = join(pluginBaseDir, version);
+                if (!isDir(installDir))
+                    continue;
+                const dirStat = safeStat(installDir);
+                const installedAt = dirStat ? Number(dirStat.mtimeMs) : 0;
+                const skills = scanSkills(installDir);
+                const mcpServerKeys = parseMcpServerKeys(installDir);
+                const mcpToolPrefixes = mcpServerKeys.map((key) => `plugin_${pluginName}_${key}`);
+                const commands = scanCommands(installDir);
+                const agentCount = countFiles(join(installDir, 'agents'));
+                const hookCount = countFiles(join(installDir, 'hooks'));
+                results.push({
+                    pluginName,
+                    marketplace,
+                    version,
+                    installDir,
+                    installedAt,
+                    skills,
+                    mcpServerKeys,
+                    mcpToolPrefixes,
+                    commands,
+                    agentCount,
+                    hookCount,
+                });
+            }
+        }
+    }
+    return results;
+}

package/dist/scanner/sessions.d.ts

@@ -3,6 +3,11 @@ export interface SessionScanResult {
     dataAvailable: boolean;
     sessionsScanned: number;
     sessionsInWindow: number;
+    mcpPrefixesInvoked: Set<string>;
+    commandsInvoked: Set<string>;
+    totalUserCallableInvocations: number;
 }
 export declare function extractSkillsFromTranscript(content: string): string[];
+export declare function extractMcpPrefixesFromTranscript(content: string): Set<string>;
+export declare function extractCommandsFromTranscript(content: string): Set<string>;
 export declare function scanSessionUsage(lookbackDays: number): Promise<SessionScanResult>;

package/dist/scanner/sessions.js

@@ -79,6 +79,116 @@ export function extractSkillsFromTranscript(content) {
     }
     return skills;
 }
+// Extract MCP server prefixes from tool_use events whose name matches
+// `mcp__<prefix>__<tool>`. Returns the set of unique prefixes seen.
+//
+// Example: `mcp__plugin_oh-my-claudecode_t__lsp_diagnostics` → `plugin_oh-my-claudecode_t`
+export function extractMcpPrefixesFromTranscript(content) {
+    const prefixes = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof obj !== 'object' || obj === null)
+            continue;
+        const message = obj.message;
+        if (typeof message !== 'object' || message === null)
+            continue;
+        const msgContent = message.content;
+        if (!Array.isArray(msgContent))
+            continue;
+        for (const c of msgContent) {
+            if (typeof c !== 'object' || c === null)
+                continue;
+            const rec = c;
+            if (rec.type !== 'tool_use')
+                continue;
+            const name = rec.name;
+            if (typeof name !== 'string' || !name.startsWith('mcp__'))
+                continue;
+            // Must have at least two __ separators: mcp__<prefix>__<tool>
+            const after = name.slice('mcp__'.length);
+            const sep = after.indexOf('__');
+            if (sep === -1)
+                continue;
+            prefixes.add(after.slice(0, sep));
+        }
+    }
+    return prefixes;
+}
+// Extract slash command names from user messages containing the
+// `<command-name>/foo</command-name>` tag that Claude Code injects when a
+// user runs a slash command. The leading slash is stripped so callers receive
+// plain names like "clear" or "grill-me".
+//
+// Only `type === "user"` / `role === "user"` messages are examined to avoid
+// false positives from assistant text that may reference command names.
+export function extractCommandsFromTranscript(content) {
+    const commands = new Set();
+    const TAG_RE = /<command-name>([^<]+)<\/command-name>/g;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof obj !== 'object' || obj === null)
+            continue;
+        const rec = obj;
+        // Only inspect user-role messages
+        const message = rec.message;
+        if (typeof message !== 'object' || message === null)
+            continue;
+        const msgRec = message;
+        if (msgRec.role !== 'user')
+            continue;
+        const msgContent = msgRec.content;
+        // User content may be a plain string or an array of content blocks.
+        const texts = [];
+        if (typeof msgContent === 'string') {
+            texts.push(msgContent);
+        }
+        else if (Array.isArray(msgContent)) {
+            for (const c of msgContent) {
+                if (typeof c !== 'object' || c === null)
+                    continue;
+                const text = c.text;
+                if (typeof text === 'string')
+                    texts.push(text);
+            }
+        }
+        for (const text of texts) {
+            TAG_RE.lastIndex = 0;
+            let match;
+            while ((match = TAG_RE.exec(text)) !== null) {
+                // Strip leading slash from the command value (e.g. "/clear" → "clear")
+                const raw = match[1].trim();
+                commands.add(raw.startsWith('/') ? raw.slice(1) : raw);
+            }
+        }
+    }
+    return commands;
+}
+// Parse all signals from a single JSONL transcript.
+function parseTranscript(content) {
+    const skills = extractSkillsFromTranscript(content);
+    const mcpPrefixes = Array.from(extractMcpPrefixesFromTranscript(content));
+    const commands = Array.from(extractCommandsFromTranscript(content));
+    const invocationCount = skills.length + mcpPrefixes.length + commands.length;
+    return { skills, mcpPrefixes, commands, invocationCount };
+}
 // Walk every `~/.claude/projects/<slug>/*.jsonl` whose mtime falls inside the
 // lookback window. Per-file results are cached by mtime, so warm scans only
 // re-read files that have changed.
@@ -90,6 +200,9 @@ export async function scanSessionUsage(lookbackDays) {
     // across many scans even as old session logs get rotated/deleted.
     const newEntries = {};
     const invokedSkills = new Set();
+    const mcpPrefixesInvoked = new Set();
+    const commandsInvoked = new Set();
+    let totalUserCallableInvocations = 0;
     let sessionsScanned = 0;
     let sessionsInWindow = 0;
     let projectDirs = [];
@@ -97,7 +210,15 @@ export async function scanSessionUsage(lookbackDays) {
         projectDirs = await readdir(projectsDir);
     }
     catch {
-        return { invokedSkills, dataAvailable: false, sessionsScanned: 0, sessionsInWindow: 0 };
+        return {
+            invokedSkills,
+            dataAvailable: false,
+            sessionsScanned: 0,
+            sessionsInWindow: 0,
+            mcpPrefixesInvoked,
+            commandsInvoked,
+            totalUserCallableInvocations: 0,
+        };
     }
     for (const projectName of projectDirs) {
         const projectPath = join(projectsDir, projectName);
@@ -123,11 +244,21 @@ export async function scanSessionUsage(lookbackDays) {
             if (mtimeMs < cutoffMs)
                 continue;
             sessionsInWindow++;
-            // Cache hit: reuse the parsed skill list, no I/O on the file body.
+            // Cache hit: reuse the parsed result only if mtime matches AND the entry
+            // has the v2.6 extension fields (mcpPrefixes / commands). Entries from
+            // older cache files lack these fields → force a re-parse.
             const cached = cache.entries[filePath];
-            if (cached && cached.mtimeMs === mtimeMs) {
+            if (cached &&
+                cached.mtimeMs === mtimeMs &&
+                Array.isArray(cached.mcpPrefixes) &&
+                Array.isArray(cached.commands)) {
                 for (const s of cached.skills)
                     invokedSkills.add(s);
+                for (const p of cached.mcpPrefixes)
+                    mcpPrefixesInvoked.add(p);
+                for (const cmd of cached.commands)
+                    commandsInvoked.add(cmd);
+                totalUserCallableInvocations += cached.invocationCount ?? 0;
                 newEntries[filePath] = cached;
                 continue;
             }
@@ -138,13 +269,32 @@ export async function scanSessionUsage(lookbackDays) {
             catch {
                 continue;
             }
-            const skills = extractSkillsFromTranscript(content);
-            for (const s of skills)
+            const parsed = parseTranscript(content);
+            for (const s of parsed.skills)
                 invokedSkills.add(s);
-            newEntries[filePath] = { mtimeMs, skills: Array.from(new Set(skills)) };
+            for (const p of parsed.mcpPrefixes)
+                mcpPrefixesInvoked.add(p);
+            for (const cmd of parsed.commands)
+                commandsInvoked.add(cmd);
+            totalUserCallableInvocations += parsed.invocationCount;
+            newEntries[filePath] = {
+                mtimeMs,
+                skills: Array.from(new Set(parsed.skills)),
+                mcpPrefixes: Array.from(new Set(parsed.mcpPrefixes)),
+                commands: Array.from(new Set(parsed.commands)),
+                invocationCount: parsed.invocationCount,
+            };
         }
     }
     const dataAvailable = sessionsInWindow >= MIN_SESSIONS_FOR_DATA_AVAILABLE && invokedSkills.size > 0;
     await saveCache({ version: CACHE_VERSION, entries: newEntries });
-    return { invokedSkills, dataAvailable, sessionsScanned, sessionsInWindow };
+    return {
+        invokedSkills,
+        dataAvailable,
+        sessionsScanned,
+        sessionsInWindow,
+        mcpPrefixesInvoked,
+        commandsInvoked,
+        totalUserCallableInvocations,
+    };
 }