claude-slim 2.6.1 → 2.7.1

package/dist/scanner/detectors.js

@@ -40,9 +40,11 @@ const duplicateDetector = {
         const pluginSkillNames = new Set(pluginSkills.map((s) => s.name));
         const issues = [];
         for (const skill of localSkills) {
-            // Check base name for nested skills (e.g. "org/ship" → "ship")
-            const baseName = skill.name.includes('/') ? skill.name.split('/').pop() : skill.name;
-            if (pluginSkillNames.has(baseName)) {
+            // Exact-name match only. A prior baseName fallback flagged nested local
+            // skills (e.g. `org/ship`) as duplicates of a bare plugin `ship`, but
+            // namespaced local skills are addressable independently and are not real
+            // duplicates — the fallback risked disabling user content.
+            if (pluginSkillNames.has(skill.name)) {
                 issues.push({
                     type: 'duplicate',
                     tier: 2,
@@ -175,6 +177,49 @@ const unusedSkillDetector = {
         return issues;
     },
 };
+const unusedPluginDetector = {
+    name: 'unused_plugin',
+    detect({ pluginSurfaces, enabledPlugins, recentSkillInvocations, recentMcpPrefixes, recentCommands, totalUserCallableInvocations, sessionsInWindow, lookbackDays, pluginCosts, }) {
+        // (a) Global suppression: too few sessions to draw a conclusion
+        if (sessionsInWindow < 3)
+            return [];
+        // (b) Global suppression: no user-callable activity — schema change suspected
+        if (totalUserCallableInvocations === 0)
+            return [];
+        const enabledNames = new Set(enabledPlugins.map((p) => p.name));
+        const issues = [];
+        for (const ps of pluginSurfaces) {
+            // Inner-join: only consider plugins reported as enabled (filters .git noise)
+            if (!enabledNames.has(ps.pluginName))
+                continue;
+            // (c) Per-plugin suppression: no user-callable surface (agent/hook only)
+            const userCallableCount = ps.skills.length + ps.mcpToolPrefixes.length + ps.commands.length;
+            if (userCallableCount === 0)
+                continue;
+            // (d) suppression was intended to skip recently-installed plugins by
+            // `installedAt` mtime, but dogfooding showed `claude plugin update` resets
+            // cache mtime indiscriminately, making install age unreliable. Dropped.
+            // Tier 3 (never auto-selected) lets users sanity-check any flagged plugin.
+            // Usage check: any skill/mcp/command from this plugin invoked?
+            const usedSkill = ps.skills.some((s) => recentSkillInvocations.has(s) ||
+                recentSkillInvocations.has(`${ps.pluginName}:${s}`));
+            const usedMcp = ps.mcpToolPrefixes.some((p) => recentMcpPrefixes.has(p));
+            const usedCmd = ps.commands.some((c) => recentCommands.has(c));
+            if (usedSkill || usedMcp || usedCmd)
+                continue;
+            issues.push({
+                type: 'unused_plugin',
+                tier: 3,
+                name: ps.pluginName,
+                marketplace: ps.marketplace,
+                detail: `not invoked in ${lookbackDays}d (${ps.marketplace})`,
+                tokens: pluginCosts.get(ps.pluginName) ?? 0,
+                path: ps.installDir,
+            });
+        }
+        return issues;
+    },
+};
 const disabledPluginDetector = {
     name: 'disabled_plugin',
     detect({ plugins, disabledPlugins }) {
@@ -206,6 +251,7 @@ export const detectors = [
     oversizedMemoryDetector,
     staleProjectDetector,
     unusedSkillDetector,
+    unusedPluginDetector,
     disabledPluginDetector,
 ];
 export function classifyIssues(ctx, registry = detectors) {

package/dist/scanner/disabled-plugins.d.ts

@@ -1,2 +1,9 @@
 export declare function parseDisabledPlugins(output: string): Set<string>;
 export declare function getDisabledPlugins(): Promise<Set<string>>;
+export interface InstalledPlugin {
+    name: string;
+    marketplace: string;
+    enabled: boolean;
+}
+export declare function parseInstalledPlugins(output: string): InstalledPlugin[];
+export declare function getInstalledPlugins(): Promise<InstalledPlugin[]>;

package/dist/scanner/disabled-plugins.js

@@ -24,3 +24,41 @@ export function parseDisabledPlugins(output) {
 export async function getDisabledPlugins() {
     return parseDisabledPlugins(await runCommand('claude', ['plugin', 'list']));
 }
+// Parse `claude plugin list` output into per-plugin entries. Unlike
+// parseDisabledPlugins (which collapses to marketplace name for cache-dir
+// matching), this preserves the full <plugin>@<marketplace> pair so callers
+// can match against plugin surface scanning by exact plugin name.
+export function parseInstalledPlugins(output) {
+    const plugins = [];
+    if (!output)
+        return plugins;
+    let current = null;
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('❯')) {
+            const full = trimmed.split('❯')[1]?.trim() || '';
+            const at = full.indexOf('@');
+            if (at > 0) {
+                current = { name: full.slice(0, at), marketplace: full.slice(at + 1) };
+            }
+            else if (full) {
+                current = { name: full, marketplace: full };
+            }
+            else {
+                current = null;
+            }
+        }
+        else if (current && trimmed.toLowerCase().includes('disabled')) {
+            plugins.push({ ...current, enabled: false });
+            current = null;
+        }
+        else if (current && trimmed.toLowerCase().includes('enabled')) {
+            plugins.push({ ...current, enabled: true });
+            current = null;
+        }
+    }
+    return plugins;
+}
+export async function getInstalledPlugins() {
+    return parseInstalledPlugins(await runCommand('claude', ['plugin', 'list']));
+}

package/dist/scanner/index.js

@@ -7,9 +7,12 @@ 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 { computePluginCosts } from './plugin-cost.js';
 import { SKILL_PROMPT_OVERHEAD_TOKENS } from './constants.js';
 const DEFAULT_LOOKBACK_DAYS = 60;
 export async function scan(opts = {}) {
@@ -22,10 +25,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;
@@ -33,6 +45,14 @@ export async function scan(opts = {}) {
         ? countTokensCached(claudeMdContent, join(getClaudeDir(), 'CLAUDE.md'))
         : 0;
     const claudeMdSections = claudeMdContent ? parseClaudeMdSections(claudeMdContent) : [];
+    // Per-plugin cost map for the unused_plugin detector's savings estimate.
+    // Aggregates when multiple surface entries share a pluginName (mirrors the
+    // same logic in computePluginBreakdown).
+    const pluginCostBreakdowns = computePluginCosts(pluginSurfaces, claudeMdSections);
+    const pluginCosts = new Map();
+    for (const c of pluginCostBreakdowns) {
+        pluginCosts.set(c.pluginName, (pluginCosts.get(c.pluginName) ?? 0) + c.totalEstimatedTokens);
+    }
     const issues = classifyIssues({
         localSkills, pluginSkills, brokenSymlinks, memoryFiles,
         tempCaches, staleProjects, disabledPlugins, plugins,
@@ -40,6 +60,24 @@ 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,
+        pluginCosts,
+    });
+    // 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 +96,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>;