runwork 0.15.1 → 0.15.2

package/dist/agents/__tests__/chatgpt-registry.test.js

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getAgent, getAgentFamily, getFamilyAgents, isConnectOnlyAgent, isWebAgent, } from '../registry-data.js';
-describe('ChatGPT registry entries', () => {
-    it('registers both Web and Desktop entries', () => {
-        const web = getAgent('chatgpt');
-        const app = getAgent('chatgpt-app');
-        expect(web).toBeDefined();
-        expect(app).toBeDefined();
-        expect(web?.category).toBe('web');
-        expect(app?.category).toBe('desktop');
-        expect(web?.firstClass).toBe(true);
-        expect(app?.firstClass).toBe(true);
-    });
-    it('treats Web entry as always-available with a URL launch', () => {
-        const web = getAgent('chatgpt');
-        expect(web?.detection).toEqual({ method: 'always' });
-        expect(web?.launch?.url).toContain('chatgpt.com');
-        expect(isWebAgent('chatgpt')).toBe(true);
-        expect(isWebAgent('chatgpt-app')).toBe(false);
-    });
-    it('marks both entries connect-only (no local config paths)', () => {
-        for (const slug of ['chatgpt', 'chatgpt-app']) {
-            const agent = getAgent(slug);
-            expect(isConnectOnlyAgent(agent)).toBe(true);
-            expect(agent?.skillsPaths).toBeUndefined();
-            expect(agent?.mcpConfigPath).toBeUndefined();
-            expect(agent?.instructionFile).toBeUndefined();
-        }
-    });
-    it('does not mark file-backed agents as connect-only', () => {
-        expect(isConnectOnlyAgent(getAgent('claude-code'))).toBe(false);
-        expect(isConnectOnlyAgent(getAgent('codex'))).toBe(false);
-    });
-    it('groups both entries under one family', () => {
-        expect(getAgentFamily('chatgpt')).toBe('chatgpt');
-        expect(getAgentFamily('chatgpt-app')).toBe('chatgpt');
-        const family = getFamilyAgents('chatgpt').map((a) => a.slug).sort();
-        expect(family).toEqual(['chatgpt', 'chatgpt-app']);
-    });
-    it('falls back to the slug as family for standalone agents', () => {
-        expect(getAgentFamily('claude-code')).toBe('claude-code');
-        expect(getFamilyAgents('claude-code').map((a) => a.slug)).toEqual(['claude-code']);
-    });
-    it('provides team/personal manual-setup variants and a copyable MCP URL', () => {
-        for (const slug of ['chatgpt', 'chatgpt-app']) {
-            const setup = getAgent(slug)?.manualSetup;
-            expect(setup?.showAfter).toBe('connecting');
-            expect(setup?.copyValue?.token).toBe('{mcpUrl}');
-            const keys = setup?.variants?.map((v) => v.key).sort();
-            expect(keys).toEqual(['personal', 'team']);
-            // Every variant carries at least one step.
-            for (const variant of setup?.variants ?? []) {
-                expect(variant.steps.length).toBeGreaterThan(0);
-            }
-        }
-    });
-    it('uses url-prompt resume for connect-only ChatGPT entries', () => {
-        expect(getAgent('chatgpt')?.resumeCapability?.mode).toBe('url-prompt');
-        expect(getAgent('chatgpt-app')?.resumeCapability?.mode).toBe('url-prompt');
-    });
-});

package/dist/agents/__tests__/claude-code-managed-block.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/agents/__tests__/claude-code-managed-block.test.js

@@ -1,105 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { ClaudeCodeAdapter } from '../claude-code.js';
-const MARKER = '# runwork-managed';
-let homeDir;
-let originalHome;
-beforeEach(() => {
-    originalHome = process.env.HOME;
-    homeDir = join(tmpdir(), `runwork-cc-managed-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(homeDir, '.claude'), { recursive: true });
-    process.env.HOME = homeDir;
-});
-afterEach(() => {
-    if (originalHome)
-        process.env.HOME = originalHome;
-    else
-        delete process.env.HOME;
-    try {
-        rmSync(homeDir, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-    vi.restoreAllMocks();
-});
-function settingsPath() {
-    return join(homeDir, '.claude', 'settings.json');
-}
-function writeSettings(settings) {
-    writeFileSync(settingsPath(), JSON.stringify(settings, null, 2));
-}
-function readSettings() {
-    return JSON.parse(readFileSync(settingsPath(), 'utf-8'));
-}
-describe('ClaudeCodeAdapter.readManagedBlock (markerless)', () => {
-    it('returns undefined when settings.json is missing', async () => {
-        const adapter = new ClaudeCodeAdapter();
-        expect(await adapter.readManagedBlock('user')).toBeUndefined();
-    });
-    it('returns undefined even when a legacy marker is present (no on-disk read)', async () => {
-        writeSettings({ permissions: { allow: [MARKER, 'Bash(runwork *)'], deny: [] } });
-        const adapter = new ClaudeCodeAdapter();
-        expect(await adapter.readManagedBlock('user')).toBeUndefined();
-    });
-});
-describe('ClaudeCodeAdapter.writeAgentConfig legacy-marker migration', () => {
-    it('strips the legacy marker from allow and deny when injecting new rules', async () => {
-        writeSettings({
-            permissions: {
-                allow: [MARKER, 'Bash(runwork *)', 'Bash(git status)'],
-                deny: [MARKER, 'Bash(rm -rf *)'],
-            },
-        });
-        const adapter = new ClaudeCodeAdapter();
-        await adapter.writeAgentConfig({ permissionRules: { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: ['Bash(rm -rf *)'] } }, 'user', { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: ['Bash(rm -rf *)'] });
-        const perms = readSettings().permissions;
-        expect(perms.allow).not.toContain(MARKER);
-        expect(perms.deny).not.toContain(MARKER);
-        expect(perms.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
-        expect(perms.deny).toEqual(['Bash(rm -rf *)']);
-    });
-    it('strips the legacy marker even when there are no new permission rules', async () => {
-        writeSettings({
-            permissions: {
-                allow: ['Bash(user-custom)', MARKER, 'Bash(runwork *)'],
-                deny: [MARKER],
-            },
-        });
-        const adapter = new ClaudeCodeAdapter();
-        await adapter.writeAgentConfig({}, 'user');
-        const perms = readSettings().permissions;
-        expect(perms.allow).toEqual(['Bash(user-custom)', 'Bash(runwork *)']);
-        expect(perms.deny).toEqual([]);
-    });
-});
-describe('ClaudeCodeAdapter.writeAgentConfig markerless merge', () => {
-    it('preserves user entries and subtracts the baseline before re-injecting', async () => {
-        writeSettings({
-            permissions: {
-                allow: ['Bash(user-custom)', 'Bash(runwork *)', 'Bash(old-default)'],
-            },
-        });
-        const adapter = new ClaudeCodeAdapter();
-        await adapter.writeAgentConfig({ permissionRules: { allow: ['Bash(runwork *)', 'Bash(git status)'] } }, 'user', { allow: ['Bash(runwork *)', 'Bash(old-default)'] });
-        // user entry kept; baseline-only entry (old-default) dropped; new managed set appended
-        expect(readSettings().permissions.allow).toEqual([
-            'Bash(user-custom)',
-            'Bash(runwork *)',
-            'Bash(git status)',
-        ]);
-    });
-    it('writes model preference and defaultMode', async () => {
-        const adapter = new ClaudeCodeAdapter();
-        await adapter.writeAgentConfig({ modelPreference: 'claude-sonnet-4-6', permissionRules: { allow: ['Bash(runwork *)'], defaultMode: 'acceptEdits' } }, 'user');
-        const settings = readSettings();
-        expect(settings.model).toBe('claude-sonnet-4-6');
-        expect(settings.permissions.defaultMode).toBe('acceptEdits');
-        expect(settings.permissions.allow).toEqual(['Bash(runwork *)']);
-    });
-    it('does not create an empty settings file when there is nothing to write', async () => {
-        const adapter = new ClaudeCodeAdapter();
-        await adapter.writeAgentConfig({}, 'user');
-        expect(existsSync(settingsPath())).toBe(false);
-    });
-});

package/dist/agents/__tests__/claude-code-plugin.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,47 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mkdtempSync, readFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-let mockHomeDir = '/tmp/runwork-cli-tests';
-vi.mock('os', async () => {
-    const actual = await vi.importActual('os');
-    return {
-        ...actual,
-        homedir: vi.fn(() => mockHomeDir),
-    };
-});
-import { ClaudeCodeAdapter } from '../claude-code.js';
-describe('ClaudeCodeAdapter MCP plugin files', () => {
-    let tempHomeDir;
-    beforeEach(() => {
-        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-cli-claude-code-'));
-        mockHomeDir = tempHomeDir;
-    });
-    afterEach(() => {
-        rmSync(tempHomeDir, { recursive: true, force: true });
-    });
-    it('writes the Runwork MCP config into the marketplace plugin directory', async () => {
-        const adapter = new ClaudeCodeAdapter();
-        const server = {
-            name: 'Runwork',
-            url: 'https://runwork.ai/api/workspaces/test/mcp',
-            transport: 'streamable-http',
-            headers: {
-                Authorization: 'Bearer test-token',
-            },
-            description: 'Runwork workspace tools',
-        };
-        await adapter.writeMcpServers([server], 'user');
-        const cacheMcpPath = join(tempHomeDir, '.claude', 'plugins', 'cache', 'runwork', 'runwork', '1.0.0', '.mcp.json');
-        const marketplaceMcpPath = join(tempHomeDir, '.claude', 'plugins', 'marketplaces', 'runwork', 'plugins', 'runwork', '.mcp.json');
-        const cacheConfig = JSON.parse(readFileSync(cacheMcpPath, 'utf-8'));
-        const marketplaceConfig = JSON.parse(readFileSync(marketplaceMcpPath, 'utf-8'));
-        expect(marketplaceConfig).toEqual(cacheConfig);
-        expect(marketplaceConfig).toMatchObject({
-            'Runwork': {
-                type: 'http',
-                url: 'https://runwork.ai/api/workspaces/test/mcp',
-            },
-        });
-    });
-});

package/dist/agents/__tests__/claude-code-stats.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,390 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { homedir } from 'os';
-import { execFileSync } from 'child_process';
-vi.mock('fs');
-vi.mock('os');
-vi.mock('child_process');
-// Avoid side-effects from other imports in claude-code.ts that use fs/os
-vi.mock('../utils/json-config.js', () => ({
-    mergeJsonMcpServers: vi.fn(),
-    readJsonConfig: vi.fn(() => ({})),
-    writeJsonConfig: vi.fn(),
-}));
-vi.mock('../utils/instruction-hint.js', () => ({
-    writeHintToFile: vi.fn(),
-}));
-import { ClaudeCodeAdapter } from '../claude-code.js';
-const HOME = '/mock-home';
-const CLAUDE_DIR = `${HOME}/.claude`;
-const PROJECTS_DIR = `${CLAUDE_DIR}/projects`;
-let adapter;
-beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.mocked(homedir).mockReturnValue(HOME);
-    adapter = new ClaudeCodeAdapter();
-});
-// Helper: make existsSync return true only for specified paths
-function mockExistsPaths(paths) {
-    vi.mocked(existsSync).mockImplementation((p) => paths.includes(p));
-}
-function jsonl(entries) {
-    return entries.map(e => {
-        const obj = { type: e.type };
-        if (e.ts)
-            obj.timestamp = e.ts;
-        if (e.type === 'user') {
-            obj.message = { role: 'user', content: e.content ?? 'hello' };
-        }
-        else if (e.type === 'assistant') {
-            obj.message = {
-                role: 'assistant',
-                content: e.content ?? [{ type: 'text', text: 'hi' }],
-                ...(e.usage ? { usage: e.usage } : {}),
-            };
-        }
-        return JSON.stringify(obj);
-    }).join('\n');
-}
-describe('ClaudeCodeAdapter.readUsageStats', () => {
-    it('parses an active session JSONL and aggregates messages, tool calls, and tokens', async () => {
-        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
-        vi.mocked(readdirSync).mockImplementation((p) => {
-            if (p === PROJECTS_DIR)
-                return ['-Users-test-project'];
-            if (p === `${PROJECTS_DIR}/-Users-test-project`) {
-                return ['sess-a.jsonl'];
-            }
-            return [];
-        });
-        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
-        vi.mocked(readFileSync).mockReturnValue(jsonl([
-            { type: 'user', ts: '2026-04-13T22:00:00.000Z' },
-            { type: 'assistant', ts: '2026-04-13T22:00:05.000Z',
-                content: [{ type: 'text', text: 'response' }],
-                usage: { input_tokens: 100, output_tokens: 50, cache_read_input_tokens: 1000 } },
-            { type: 'assistant', ts: '2026-04-13T22:00:10.000Z',
-                content: [{ type: 'tool_use', name: 'Read' }, { type: 'tool_use', name: 'Edit' }],
-                usage: { input_tokens: 50, output_tokens: 20 } },
-            { type: 'user', ts: '2026-04-13T22:00:15.000Z' },
-            // Lines without timestamps are ignored
-            { type: 'permission-mode' },
-        ]));
-        const stats = await adapter.readUsageStats(null);
-        expect(stats).not.toBeNull();
-        expect(stats.hasNewActivity).toBe(true);
-        expect(stats.sessionCount).toBe(1);
-        expect(stats.messageCount).toBe(4); // 2 user + 2 assistant
-        expect(stats.toolCallCount).toBe(2);
-        expect(stats.tokensUsed).toBe(220); // 150 input + 70 output (cache_read in extra)
-        expect(stats.lastActiveAt).toBe('2026-04-13T22:00:15.000Z');
-        expect(stats.extra).toEqual({ inputTokens: 150, outputTokens: 70, cacheReadTokens: 1000 });
-    });
-    it('filters out entries with timestamp <= lastSyncAt within the same file', async () => {
-        const sinceIso = '2026-04-13T20: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: Date.parse('2026-04-13T22:00:00Z') });
-        vi.mocked(readFileSync).mockReturnValue(jsonl([
-            { type: 'user', ts: '2026-04-13T19:00:00.000Z' }, // before sync, ignored
-            { type: 'assistant', ts: '2026-04-13T19:30:00.000Z',
-                usage: { input_tokens: 999, output_tokens: 999 } }, // before sync, tokens NOT counted
-            { type: 'user', ts: '2026-04-13T21:00:00.000Z' }, // after sync, counted
-            { type: 'assistant', ts: '2026-04-13T21:00:05.000Z',
-                content: [{ type: 'tool_use', name: 'Read' }],
-                usage: { input_tokens: 10, output_tokens: 5 } },
-        ]));
-        const stats = await adapter.readUsageStats(sinceIso);
-        expect(stats).not.toBeNull();
-        expect(stats.messageCount).toBe(2); // only post-sync entries
-        expect(stats.toolCallCount).toBe(1);
-        expect(stats.tokensUsed).toBe(15); // 10 + 5, pre-sync 999+999 ignored
-        expect(stats.sessionCount).toBe(1);
-    });
-    it('skips JSONL files with mtime <= lastSyncAt without parsing them', async () => {
-        const sinceIso = '2026-04-13T20: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 ['stale.jsonl'];
-            return [];
-        });
-        // mtime is BEFORE sinceMs - file should be skipped entirely
-        vi.mocked(statSync).mockReturnValue({ mtimeMs: Date.parse('2026-04-13T18:00:00Z') });
-        const readSpy = vi.mocked(readFileSync);
-        const stats = await adapter.readUsageStats(sinceIso);
-        expect(stats).toBeNull();
-        expect(readSpy).not.toHaveBeenCalled();
-    });
-    it('counts multiple sessions across multiple cwd directories', async () => {
-        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
-        vi.mocked(readdirSync).mockImplementation((p) => {
-            const path = p;
-            if (path === PROJECTS_DIR) {
-                return ['-Users-a-proj1', '-Users-a-proj2'];
-            }
-            if (path === `${PROJECTS_DIR}/-Users-a-proj1`) {
-                return ['s1.jsonl'];
-            }
-            if (path === `${PROJECTS_DIR}/-Users-a-proj2`) {
-                return ['s2.jsonl', 's3.jsonl'];
-            }
-            return [];
-        });
-        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
-        vi.mocked(readFileSync).mockReturnValue(jsonl([
-            { type: 'user', ts: '2026-04-13T22:00:00.000Z' },
-            { type: 'assistant', ts: '2026-04-13T22:00:05.000Z' },
-        ]));
-        const stats = await adapter.readUsageStats(null);
-        expect(stats).not.toBeNull();
-        expect(stats.sessionCount).toBe(3);
-        expect(stats.messageCount).toBe(6); // 2 messages * 3 sessions
-    });
-    it('returns null when ~/.claude does not exist', async () => {
-        mockExistsPaths([]);
-        const stats = await adapter.readUsageStats(null);
-        expect(stats).toBeNull();
-    });
-    it('returns null when ~/.claude/projects does not exist', async () => {
-        mockExistsPaths([CLAUDE_DIR]);
-        const stats = await adapter.readUsageStats(null);
-        expect(stats).toBeNull();
-    });
-    it('returns null when projects dir has no active sessions', async () => {
-        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
-        vi.mocked(readdirSync).mockImplementation((p) => {
-            if (p === PROJECTS_DIR)
-                return [];
-            return [];
-        });
-        const stats = await adapter.readUsageStats(null);
-        expect(stats).toBeNull();
-    });
-    it('skips malformed JSONL lines without crashing', 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([
-            'not json at all',
-            '{"type":"user","timestamp":"2026-04-13T22:00:00.000Z","message":{"role":"user","content":"ok"}}',
-            '{{{ broken',
-            '{"type":"assistant","timestamp":"2026-04-13T22:00:05.000Z","message":{"role":"assistant","content":[]}}',
-            '',
-        ].join('\n'));
-        const stats = await adapter.readUsageStats(null);
-        expect(stats).not.toBeNull();
-        expect(stats.messageCount).toBe(2);
-        expect(stats.sessionCount).toBe(1);
-    });
-});
-describe('ClaudeCodeAdapter.readVersion', () => {
-    it('returns version string from claude --version', async () => {
-        vi.mocked(execFileSync).mockReturnValue(Buffer.from('claude-code 1.0.23\n'));
-        const version = await adapter.readVersion();
-        expect(version).toBe('claude-code 1.0.23');
-        expect(execFileSync).toHaveBeenCalledWith('claude', ['--version'], {
-            stdio: 'pipe',
-            windowsHide: true,
-        });
-    });
-    it('returns null when claude is not installed', async () => {
-        vi.mocked(execFileSync).mockImplementation(() => {
-            throw new Error('ENOENT');
-        });
-        const version = await adapter.readVersion();
-        expect(version).toBeNull();
-    });
-});
-describe('ClaudeCodeAdapter.readSkillUsage', () => {
-    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__/claude-desktop-memory.test.d.ts

@@ -1 +0,0 @@
-export {};