runwork 0.8.4 → 0.9.1

package/dist/agents/__tests__/claude-code-stats.test.js

@@ -210,9 +210,180 @@ describe('ClaudeCodeAdapter.readVersion', () => {
     });
 });
 describe('ClaudeCodeAdapter.readSkillUsage', () => {
-    it('returns null when no skills directory exists', async () => {
-        vi.mocked(existsSync).mockReturnValue(false);
+    it('returns null when projects dir does not exist', async () => {
+        mockExistsPaths([CLAUDE_DIR]);
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).toBeNull();
+    });
+    it('detects Path A: Skill tool calls in assistant messages', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:00.000Z', message: { role: 'user', content: 'use marketing skill' } }),
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T22:00:05.000Z', message: { role: 'assistant', content: [
+                        { type: 'tool_use', name: 'Skill', input: { skill: 'marketing' }, id: 'toolu_1', caller: { type: 'direct' } },
+                    ] } }),
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T22:01:00.000Z', message: { role: 'assistant', content: [
+                        { type: 'tool_use', name: 'Skill', input: { skill: 'superpowers:brainstorming', args: 'generate ideas' }, id: 'toolu_2', caller: { type: 'direct' } },
+                    ] } }),
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T22:02:00.000Z', message: { role: 'assistant', content: [
+                        { type: 'tool_use', name: 'Skill', input: { skill: 'marketing' }, id: 'toolu_3', caller: { type: 'direct' } },
+                    ] } }),
+        ].join('\n'));
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).not.toBeNull();
+        expect(usage).toHaveLength(2);
+        const marketing = usage.find(s => s.skillName === 'marketing');
+        const brainstorming = usage.find(s => s.skillName === 'superpowers:brainstorming');
+        expect(marketing.count).toBe(2);
+        expect(brainstorming.count).toBe(1);
+        expect(marketing.lastUsedAt).toBe('2026-04-13T22:02:00.000Z');
+    });
+    it('detects Path B: slash commands followed by skill content injection', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            // Slash command invocation
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:00.000Z', message: { role: 'user', content: '<command-message>marketing</command-message>\n<command-name>/marketing</command-name>' } }),
+            // Skill content injection (confirms it was a skill, not a built-in)
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:01.000Z', message: { role: 'user', content: 'Base directory for this skill: /Users/test/.claude/skills/marketing\n\n# Marketing Skill\nhelp with marketing...' } }),
+        ].join('\n'));
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).not.toBeNull();
+        expect(usage).toHaveLength(1);
+        expect(usage[0].skillName).toBe('marketing');
+        expect(usage[0].count).toBe(1);
+    });
+    it('does NOT count slash commands that are built-in (no skill content follows)', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:00.000Z', message: { role: 'user', content: '<command-name>/clear</command-name>\n            <command-message>clear</command-message>\n            <command-args></command-args>' } }),
+            // Next message is a normal user message, not skill content
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:01:00.000Z', message: { role: 'user', content: 'help me with something' } }),
+        ].join('\n'));
         const usage = await adapter.readSkillUsage(null);
         expect(usage).toBeNull();
     });
+    it('filters skill invocations by timestamp', async () => {
+        const sinceIso = '2026-04-13T22:00:00.000Z';
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            // Before sync, should be ignored
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T21:00:00.000Z', message: { role: 'assistant', content: [
+                        { type: 'tool_use', name: 'Skill', input: { skill: 'old-skill' }, id: 'toolu_old' },
+                    ] } }),
+            // After sync, should be counted
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T23:00:00.000Z', message: { role: 'assistant', content: [
+                        { type: 'tool_use', name: 'Skill', input: { skill: 'new-skill' }, id: 'toolu_new' },
+                    ] } }),
+        ].join('\n'));
+        const usage = await adapter.readSkillUsage(sinceIso);
+        expect(usage).not.toBeNull();
+        expect(usage).toHaveLength(1);
+        expect(usage[0].skillName).toBe('new-skill');
+    });
+    it('handles both Path A and Path B in the same session', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            // Path A: model-initiated
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T22:00:00.000Z', message: { role: 'assistant', content: [
+                        { type: 'tool_use', name: 'Skill', input: { skill: 'marketing' }, id: 'toolu_1' },
+                    ] } }),
+            // Path B: user-initiated slash command
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:05:00.000Z', message: { role: 'user', content: '<command-name>/seo-review</command-name>' } }),
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:05:01.000Z', message: { role: 'user', content: 'Base directory for this skill: /Users/test/.claude/skills/seo-review\n\n# SEO Review' } }),
+        ].join('\n'));
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).not.toBeNull();
+        expect(usage).toHaveLength(2);
+        expect(usage.find(s => s.skillName === 'marketing')).toBeDefined();
+        expect(usage.find(s => s.skillName === 'seo-review')).toBeDefined();
+    });
+});
+describe('ClaudeCodeAdapter.readUsageStats dedup', () => {
+    it('deduplicates entries with same message.id + requestId', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            // Two entries with same message.id + requestId (retransmission)
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T22:00:00.000Z', requestId: 'req_1',
+                message: { id: 'msg_1', role: 'assistant', content: [{ type: 'text', text: 'hi' }],
+                    usage: { input_tokens: 100, output_tokens: 50 } } }),
+            JSON.stringify({ type: 'assistant', timestamp: '2026-04-13T22:00:01.000Z', requestId: 'req_1',
+                message: { id: 'msg_1', role: 'assistant', content: [{ type: 'text', text: 'hi' }],
+                    usage: { input_tokens: 100, output_tokens: 50 } } }),
+            // Different message, should be counted
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:05.000Z', requestId: 'req_2',
+                message: { id: 'msg_2', role: 'user', content: 'hello' } }),
+        ].join('\n'));
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).not.toBeNull();
+        expect(stats.messageCount).toBe(2); // 1 assistant (deduped) + 1 user
+    });
+    it('counts entries without message.id or requestId (no dedup possible)', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            // No message.id, both should count
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:00.000Z',
+                message: { role: 'user', content: 'hello' } }),
+            JSON.stringify({ type: 'user', timestamp: '2026-04-13T22:00:01.000Z',
+                message: { role: 'user', content: 'world' } }),
+        ].join('\n'));
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).not.toBeNull();
+        expect(stats.messageCount).toBe(2);
+    });
 });

package/dist/agents/__tests__/codex-stats.test.js

@@ -247,6 +247,99 @@ describe('CodexAdapter (codex).readUsageStats', () => {
         expect(result.messageCount).toBe(1);
     });
 });
+describe('CodexAdapter (codex).readSkillUsage', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = createCodexAdapter();
+    });
+    it('parses skill names from session_meta.instructions in rollout JSONL', async () => {
+        const sessionsDir = '/mock/home/.codex/sessions';
+        const rolloutPath = `${sessionsDir}/2026/04/20/rollout-test.jsonl`;
+        existsSync.mockImplementation((p) => {
+            if (p === sessionsDir)
+                return true;
+            return false;
+        });
+        // Mock the filesystem tree: sessions/2026/04/20/rollout-test.jsonl
+        const { readdirSync, statSync } = await import('fs');
+        readdirSync.mockImplementation((p) => {
+            if (p === sessionsDir)
+                return ['2026'];
+            if (p === `${sessionsDir}/2026`)
+                return ['04'];
+            if (p === `${sessionsDir}/2026/04`)
+                return ['20'];
+            if (p === `${sessionsDir}/2026/04/20`)
+                return ['rollout-test.jsonl'];
+            return [];
+        });
+        statSync.mockImplementation((p) => {
+            if (p.endsWith('.jsonl'))
+                return { mtimeMs: 2_000_000_000_000, isDirectory: () => false };
+            return { isDirectory: () => true, mtimeMs: 0 };
+        });
+        const sessionMeta = JSON.stringify({
+            timestamp: '2026-04-20T10:00:00.000Z',
+            type: 'session_meta',
+            payload: {
+                id: 'test-id',
+                instructions: `## Skills
+A skill is a set of local instructions.
+### Available skills
+- write-cold-email: Write a cold email for outreach (file: /home/.codex/skills/write-cold-email/SKILL.md)
+- marketing-task-tracker: Track marketing tasks (file: /home/.codex/skills/marketing-task-tracker/SKILL.md)
+- skill-creator: Guide for creating effective skills (file: /home/.codex/skills/.system/skill-creator/SKILL.md)
+- skill-installer: Install Codex skills (file: /home/.codex/skills/.system/skill-installer/SKILL.md)
+### How to use skills`,
+            },
+        });
+        readFileSync.mockReturnValue(sessionMeta);
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).not.toBeNull();
+        // Should find 2 skills (skill-creator and skill-installer are filtered as system skills)
+        expect(usage).toHaveLength(2);
+        expect(usage.find(s => s.skillName === 'write-cold-email')).toBeDefined();
+        expect(usage.find(s => s.skillName === 'marketing-task-tracker')).toBeDefined();
+        // System skills should be excluded
+        expect(usage.find(s => s.skillName === 'skill-creator')).toBeUndefined();
+    });
+    it('returns null when sessions directory does not exist', async () => {
+        existsSync.mockReturnValue(false);
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).toBeNull();
+    });
+    it('filters rollout files by mtime', async () => {
+        const sessionsDir = '/mock/home/.codex/sessions';
+        const sinceIso = '2026-04-20T12:00:00.000Z';
+        existsSync.mockImplementation((p) => {
+            if (p === sessionsDir)
+                return true;
+            return false;
+        });
+        const { readdirSync, statSync } = await import('fs');
+        readdirSync.mockImplementation((p) => {
+            if (p === sessionsDir)
+                return ['2026'];
+            if (p === `${sessionsDir}/2026`)
+                return ['04'];
+            if (p === `${sessionsDir}/2026/04`)
+                return ['20'];
+            if (p === `${sessionsDir}/2026/04/20`)
+                return ['old.jsonl'];
+            return [];
+        });
+        // File mtime is BEFORE sinceMs
+        statSync.mockImplementation((p) => {
+            if (p.endsWith('.jsonl'))
+                return { mtimeMs: Date.parse('2026-04-20T10:00:00Z'), isDirectory: () => false };
+            return { isDirectory: () => true, mtimeMs: 0 };
+        });
+        const usage = await adapter.readSkillUsage(sinceIso);
+        expect(usage).toBeNull();
+        expect(readFileSync).not.toHaveBeenCalled();
+    });
+});
 describe('CodexAdapter (codex).readVersion', () => {
     let adapter;
     beforeEach(() => {

package/dist/agents/claude-code.js

@@ -319,6 +319,9 @@ export class ClaudeCodeAdapter {
             let outputTokens = 0;
             let cacheReadTokens = 0;
             let latestActivityMs = 0;
+            // Dedup: ccusage uses ${message.id}:${requestId} to drop retransmissions.
+            // Entries without both fields pass through undeduped (same behavior).
+            const seenEntries = new Set();
             let cwdEntries;
             try {
                 cwdEntries = readdirSync(projectsDir);
@@ -377,6 +380,16 @@ export class ClaudeCodeAdapter {
                             latestActivityMs = ts;
                         const type = entry.type;
                         if (type === 'user' || type === 'assistant') {
+                            // Dedup by message.id + requestId (same approach as ccusage)
+                            const msg = entry.message;
+                            const msgId = msg && typeof msg === 'object' ? msg.id : undefined;
+                            const reqId = entry.requestId;
+                            if (typeof msgId === 'string' && typeof reqId === 'string') {
+                                const dedupKey = `${msgId}:${reqId}`;
+                                if (seenEntries.has(dedupKey))
+                                    continue;
+                                seenEntries.add(dedupKey);
+                            }
                             messageCount++;
                         }
                         if (type === 'assistant') {
@@ -427,36 +440,144 @@ export class ClaudeCodeAdapter {
         }
     }
     async readSkillUsage(lastSyncAt) {
+        // Walk the same JSONL files as readUsageStats and detect actual skill
+        // invocations. Two verified paths exist in the data:
+        //
+        // Path A (model-initiated): assistant message contains a tool_use block
+        //   with name === "Skill" and input.skill === "<skill-name>".
+        //
+        // Path B (user-initiated slash command): user message contains
+        //   <command-name>/xxx</command-name>, and the NEXT user message starts
+        //   with "Base directory for this skill:" (confirming the harness treated
+        //   it as a skill, not a built-in command).
+        //
+        // MCP skill tools (mcp__*__skill_*) are listed in deferred-tool blocks
+        // but are never actually invoked in any observed JSONL data.
         try {
-            const results = [];
+            const projectsDir = join(homedir(), '.claude', 'projects');
+            if (!existsSync(projectsDir))
+                return null;
             const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            const skillDirs = [
-                join(homedir(), '.claude', 'skills'),
-                join(process.cwd(), '.claude', 'skills'),
-            ];
-            for (const dir of skillDirs) {
-                if (!existsSync(dir))
+            const skillCounts = new Map();
+            const recordSkill = (name, ts) => {
+                const existing = skillCounts.get(name);
+                if (existing) {
+                    existing.count++;
+                    if (ts > existing.lastTs)
+                        existing.lastTs = ts;
+                }
+                else {
+                    skillCounts.set(name, { count: 1, lastTs: ts });
+                }
+            };
+            let cwdEntries;
+            try {
+                cwdEntries = readdirSync(projectsDir);
+            }
+            catch {
+                return null;
+            }
+            for (const cwd of cwdEntries) {
+                const cwdPath = join(projectsDir, cwd);
+                let files;
+                try {
+                    files = readdirSync(cwdPath);
+                }
+                catch {
                     continue;
-                for (const entry of readdirSync(dir)) {
-                    if (entry === 'runwork')
+                }
+                for (const file of files) {
+                    if (!file.endsWith('.jsonl'))
                         continue;
-                    const skillDir = join(dir, entry);
+                    const filePath = join(cwdPath, file);
+                    let fileStat;
                     try {
-                        const stat = statSync(skillDir);
-                        if (stat.mtimeMs > sinceMs) {
-                            results.push({
-                                skillName: entry,
-                                count: 1,
-                                lastUsedAt: new Date(stat.mtimeMs).toISOString(),
-                            });
-                        }
+                        fileStat = statSync(filePath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (fileStat.mtimeMs <= sinceMs)
+                        continue;
+                    let content;
+                    try {
+                        content = readFileSync(filePath, 'utf-8');
                     }
                     catch {
                         continue;
                     }
+                    // Track pending slash command for Path B lookahead
+                    let pendingCommand = null;
+                    for (const line of content.split('\n')) {
+                        if (!line)
+                            continue;
+                        let entry;
+                        try {
+                            entry = JSON.parse(line);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const tsRaw = entry.timestamp;
+                        if (typeof tsRaw !== 'string')
+                            continue;
+                        const ts = Date.parse(tsRaw);
+                        if (!Number.isFinite(ts) || ts <= sinceMs)
+                            continue;
+                        const type = entry.type;
+                        // Path A: Skill tool calls in assistant messages
+                        if (type === 'assistant') {
+                            const msg = entry.message;
+                            if (msg && typeof msg === 'object') {
+                                const blocks = Array.isArray(msg.content)
+                                    ? msg.content
+                                    : [];
+                                for (const block of blocks) {
+                                    if (block && block.type === 'tool_use' && block.name === 'Skill') {
+                                        const input = block.input;
+                                        if (input && typeof input.skill === 'string') {
+                                            recordSkill(input.skill, ts);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // Path B: slash command -> skill content injection
+                        if (type === 'user') {
+                            const msg = entry.message;
+                            const msgContent = msg?.content;
+                            const text = typeof msgContent === 'string' ? msgContent : '';
+                            // Check if this is a skill content injection following a slash command
+                            if (pendingCommand && text.startsWith('Base directory for this skill:')) {
+                                recordSkill(pendingCommand.name, pendingCommand.ts);
+                                pendingCommand = null;
+                                continue;
+                            }
+                            // Reset pending on any user message that isn't skill content
+                            if (pendingCommand && type === 'user') {
+                                pendingCommand = null;
+                            }
+                            // Check for slash command pattern
+                            const match = text.match(/<command-name>\/?([^<]+)<\/command-name>/);
+                            if (match) {
+                                const cmdName = match[1].replace(/^\//, '');
+                                pendingCommand = { name: cmdName, ts };
+                            }
+                        }
+                    }
                 }
             }
-            return results.length > 0 ? results : null;
+            if (skillCounts.size === 0)
+                return null;
+            const results = [];
+            for (const [skillName, { count, lastTs }] of skillCounts) {
+                results.push({
+                    skillName,
+                    count,
+                    lastUsedAt: new Date(lastTs).toISOString(),
+                });
+            }
+            return results;
         }
         catch {
             return null;

package/dist/agents/claude-desktop.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
 /**
  * Collect every `<session>/<org>/memory/CLAUDE.md` path under the Cowork
  * base directory. Claude Desktop loads this file on every conversation in
@@ -39,6 +39,7 @@ export declare class ClaudeDesktopAdapter implements AgentAdapter {
     cleanup(_scope: 'project' | 'user', _manifest?: CleanupManifest): Promise<void>;
     readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
     readVersion(): Promise<string | null>;
+    readSkillUsage(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
     /**
      * Walk the org/user/session directory tree and invoke callback for each session JSON.
      */

package/dist/agents/claude-desktop.js

@@ -578,6 +578,63 @@ export class ClaudeDesktopAdapter {
             return null;
         }
     }
+    async readSkillUsage(lastSyncAt) {
+        // Cowork session JSON files contain enabledMcpTools, an object whose keys
+        // are MCP tool names. Tools matching skill_* patterns indicate which skills
+        // were loaded (reach, not invocation). This is the best we can get from
+        // local data. For actual invocation data, OTEL or the Enterprise Analytics
+        // API are needed.
+        try {
+            const baseDir = getCoworkBaseDir();
+            if (!existsSync(baseDir))
+                return null;
+            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
+            const skillCounts = new Map();
+            const agentSessionsDir = baseDir;
+            this.walkSessionDirs(agentSessionsDir, sinceMs, (session) => {
+                const sessionTime = session.lastActivityAt ?? session.createdAt ?? 0;
+                if (sessionTime <= sinceMs)
+                    return;
+                const mcpTools = session.enabledMcpTools;
+                if (!mcpTools || typeof mcpTools !== 'object')
+                    return;
+                for (const toolName of Object.keys(mcpTools)) {
+                    // Match patterns like "skill_Blog_Writing_Specialist" or
+                    // "mcp__Runwork__skill_Write_Cold_Email"
+                    const skillMatch = toolName.match(/skill_([A-Za-z0-9_]+)/);
+                    if (!skillMatch)
+                        continue;
+                    // Convert Tool_Name_Format to readable name
+                    const rawName = skillMatch[1].replace(/_/g, ' ').trim();
+                    if (!rawName)
+                        continue;
+                    const existing = skillCounts.get(rawName);
+                    if (existing) {
+                        existing.count++;
+                        if (sessionTime > existing.lastTs)
+                            existing.lastTs = sessionTime;
+                    }
+                    else {
+                        skillCounts.set(rawName, { count: 1, lastTs: sessionTime });
+                    }
+                }
+            });
+            if (skillCounts.size === 0)
+                return null;
+            const results = [];
+            for (const [skillName, { count, lastTs }] of skillCounts) {
+                results.push({
+                    skillName,
+                    count,
+                    lastUsedAt: new Date(lastTs).toISOString(),
+                });
+            }
+            return results;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Walk the org/user/session directory tree and invoke callback for each session JSON.
      */

package/dist/agents/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
 export declare class CodexAdapter implements AgentAdapter {
     name: string;
     slug: string;
@@ -14,4 +14,31 @@ export declare class CodexAdapter implements AgentAdapter {
     cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
     readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
     readVersion(): Promise<string | null>;
+    readSkillUsage(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
+    /** Parse a rollout JSONL file for skill data */
+    private parseRolloutForSkills;
+    /**
+     * Register a workspace directory in the Codex desktop app's project list.
+     * Adds the path to electron-saved-workspace-roots, project-order, and
+     * electron-workspace-root-labels. Skips active-workspace-roots to avoid
+     * force-switching the user's active project.
+     *
+     * Returns 'written' if changes were made, 'already_registered' if the
+     * path was already present, or 'app_running' if Codex is open and would
+     * overwrite our changes.
+     */
+    registerDesktopWorkspace(workspacePath: string, label: string): 'written' | 'already_registered' | 'app_running';
+}
+/**
+ * Codex Desktop (OpenAI's GUI app) reads its config from the same `~/.codex`
+ * directory as the Codex CLI, so every sync/cleanup behavior inherits from
+ * CodexAdapter unchanged. Only the identity (slug/name) and the installation
+ * detection differ -- the desktop app is detected by application bundle
+ * presence, not by a `codex` binary on PATH.
+ */
+export declare class CodexDesktopAdapter extends CodexAdapter {
+    name: string;
+    slug: string;
+    detect(): Promise<boolean>;
+    readUsageStats(): Promise<null>;
 }