runwork 0.15.1 → 0.15.2

package/dist/agents/claude-code.js

@@ -1,753 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir, platform } from 'os';
-import { execFileSync } from '../utils/subprocess.js';
-import { whichBinary } from '../utils/which.js';
-import { buildSkillMd } from './types.js';
-import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig, removeRunworkMcpServers } from './utils/json-config.js';
-import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
-import { SESSION_START_HOOK_SCRIPT } from './session-start-hook.js';
-import { mergeMarkerless } from './defaults-merge.js';
-const PLUGIN_NAME = 'runwork';
-const PLUGIN_VERSION = '1.0.0';
-/**
- * Legacy in-array sentinel that older CLI versions injected at the head of the
- * managed permission block. Claude Code >= 2.1.x validates every allow/deny
- * entry as a tool rule and rejects this with "matches no known tool" on
- * startup, so the adapter is now markerless and actively strips this marker
- * from any existing user's settings on their next sync.
- */
-const LEGACY_MANAGED_MARKER = '# runwork-managed';
-function getPluginJson() {
-    return {
-        name: PLUGIN_NAME,
-        version: PLUGIN_VERSION,
-        description: 'Skills and tools from your Runwork workspace',
-        author: { name: 'Runwork' },
-        homepage: 'https://www.runwork.ai',
-    };
-}
-function getMarketplaceJson() {
-    return {
-        name: 'runwork',
-        owner: { name: 'Runwork' },
-        plugins: [
-            {
-                name: PLUGIN_NAME,
-                source: `./plugins/${PLUGIN_NAME}`,
-                description: 'Skills and tools from your Runwork workspace',
-            },
-        ],
-    };
-}
-export class ClaudeCodeAdapter {
-    name = 'Claude Code';
-    slug = 'claude-code';
-    mcpProvidesSkills = true;
-    async detect() {
-        if (whichBinary('claude'))
-            return true;
-        // Fallback: check app bundle on macOS
-        if (platform() === 'darwin')
-            return existsSync('/Applications/Claude.app');
-        return false;
-    }
-    supportsMcpScope(_scope) {
-        return true;
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, scope) {
-        if (scope === 'project') {
-            // Project scope: write to .mcp.json (standard Claude Code location)
-            const filePath = join(process.cwd(), '.mcp.json');
-            const entries = {};
-            for (const s of servers) {
-                entries[s.name] = {
-                    type: 'http',
-                    url: s.url,
-                    ...(s.headers ? { headers: s.headers } : {}),
-                    ...(s.description ? { description: s.description } : {}),
-                };
-            }
-            mergeJsonMcpServers(filePath, entries, 'mcpServers');
-        }
-        else {
-            // User scope: write MCP config both in global settings and inside the plugin
-            const settingsPath = join(homedir(), '.claude', 'settings.json');
-            const entries = {};
-            for (const s of servers) {
-                entries[s.name] = {
-                    type: 'http',
-                    url: s.url,
-                    ...(s.headers ? { headers: s.headers } : {}),
-                    ...(s.description ? { description: s.description } : {}),
-                };
-            }
-            mergeJsonMcpServers(settingsPath, entries, 'mcpServers');
-            // Also write .mcp.json in the plugin directory
-            const pluginDir = this.getPluginDir();
-            mkdirSync(pluginDir, { recursive: true });
-            const pluginMcpPath = join(pluginDir, '.mcp.json');
-            const marketDir = this.getMarketplaceDir();
-            mkdirSync(marketDir, { recursive: true });
-            const marketplaceMcpPath = join(marketDir, '.mcp.json');
-            const pluginEntries = {};
-            for (const s of servers) {
-                pluginEntries[s.name] = {
-                    type: 'http',
-                    url: s.url,
-                    ...(s.headers ? { headers: s.headers } : {}),
-                    ...(s.description ? { description: s.description } : {}),
-                };
-            }
-            writeJsonConfig(pluginMcpPath, pluginEntries);
-            writeJsonConfig(marketplaceMcpPath, pluginEntries);
-        }
-    }
-    /**
-     * Install the Runwork SessionStart hook into the plugin tree (user scope).
-     * The hook writes ~/.runwork/sessions/<sessionId>.json with the active
-     * conversation's transcript path + metadata, used by `runwork share-convo`
-     * for high-fidelity capture and by `runwork resume` for placement.
-     *
-     * Called as part of user-scope writeSkills() to keep sync flow consistent.
-     * Emits a one-line confirmation matching the format other adapter steps
-     * use (`  [Claude Code] Installed ... (user)`) so `runwork sync` output
-     * shows whether the hook actually landed.
-     */
-    installSessionStartHook(pluginDir, label) {
-        const hooksDir = join(pluginDir, 'hooks');
-        mkdirSync(hooksDir, { recursive: true });
-        const scriptPath = join(hooksDir, 'on-session-start.sh');
-        writeFileSync(scriptPath, SESSION_START_HOOK_SCRIPT);
-        try {
-            // Best-effort executable bit; chmod is a no-op on Windows.
-            chmodSync(scriptPath, 0o755);
-        }
-        catch {
-            /* not fatal */
-        }
-        const hooksManifest = {
-            SessionStart: [
-                { command: '${CLAUDE_PLUGIN_ROOT}/hooks/on-session-start.sh' },
-            ],
-        };
-        writeFileSync(join(hooksDir, 'hooks.json'), JSON.stringify(hooksManifest, null, 2));
-        console.log(`  [Claude Code] Installed SessionStart hook (${label}) -> ${scriptPath}`);
-    }
-    async writeSkills(skills, scope) {
-        // Always write to the standard skills directory (guaranteed to work)
-        const baseDir = scope === 'project'
-            ? join(process.cwd(), '.claude', 'skills')
-            : join(homedir(), '.claude', 'skills');
-        for (const skill of skills) {
-            const skillDir = join(baseDir, skill.filename);
-            cleanupOldSkillDir(baseDir, skill);
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
-        }
-        // User scope: also write as a plugin for native plugin UI support
-        if (scope === 'user') {
-            const pluginDir = this.getPluginDir();
-            // Create plugin.json
-            const pluginJsonDir = join(pluginDir, '.claude-plugin');
-            mkdirSync(pluginJsonDir, { recursive: true });
-            writeFileSync(join(pluginJsonDir, 'plugin.json'), JSON.stringify(getPluginJson(), null, 2));
-            // Write skill files inside the plugin
-            for (const skill of skills) {
-                const skillDir = join(pluginDir, 'skills', skill.filename);
-                cleanupOldSkillDir(join(pluginDir, 'skills'), skill);
-                mkdirSync(skillDir, { recursive: true });
-                writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
-            }
-            // Also write to the marketplace directory
-            const marketDir = this.getMarketplaceDir();
-            const marketPluginJsonDir = join(marketDir, '.claude-plugin');
-            mkdirSync(marketPluginJsonDir, { recursive: true });
-            writeFileSync(join(marketPluginJsonDir, 'plugin.json'), JSON.stringify(getPluginJson(), null, 2));
-            for (const skill of skills) {
-                const skillDir = join(marketDir, 'skills', skill.filename);
-                cleanupOldSkillDir(join(marketDir, 'skills'), skill);
-                mkdirSync(skillDir, { recursive: true });
-                writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
-            }
-            // Register in installed_plugins.json
-            this.registerPlugin(pluginDir);
-        }
-    }
-    /**
-     * Install the runwork SessionStart hook for Claude Code (user scope only).
-     * Called once per sync by the main sync loop AFTER writeSkills has
-     * populated the plugin directories. Kept separate from writeSkills because
-     * writeSkills is also invoked per-skill by the diff executor during
-     * push/pull, and the hook install + log line must not repeat for every
-     * skill change.
-     */
-    async writeBuiltInHooks(scope) {
-        if (scope !== 'user')
-            return;
-        const pluginDir = this.getPluginDir();
-        const marketDir = this.getMarketplaceDir();
-        if (existsSync(pluginDir)) {
-            this.installSessionStartHook(pluginDir, 'plugin cache');
-        }
-        if (existsSync(marketDir)) {
-            this.installSessionStartHook(marketDir, 'marketplace');
-        }
-    }
-    async writeInstructionHint(hint, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.claude', 'CLAUDE.md')
-            : join(homedir(), '.claude', 'CLAUDE.md');
-        writeHintToFile(filePath, hint);
-    }
-    async writeTeamInstructions(instructions, scope) {
-        // Write to CLAUDE.md via markers (direct instruction file approach)
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.claude', 'CLAUDE.md')
-            : join(homedir(), '.claude', 'CLAUDE.md');
-        writeTeamInstructionsToFile(filePath, instructions);
-        // Also write as a plugin skill (same mechanism as Claude Desktop)
-        if (scope === 'user') {
-            const skillContent = `---\nname: runwork-team-instructions\ndescription: Team instructions from your Runwork workspace. Always follow these guidelines.\n---\n\n${instructions}`;
-            const pluginDir = this.getPluginDir();
-            const marketDir = this.getMarketplaceDir();
-            for (const dir of [
-                join(pluginDir, 'skills', 'runwork-team-instructions'),
-                join(marketDir, 'skills', 'runwork-team-instructions'),
-            ]) {
-                mkdirSync(dir, { recursive: true });
-                writeFileSync(join(dir, 'SKILL.md'), skillContent);
-            }
-        }
-    }
-    // ── Agent config (model, permissions) ──────────────────────────────
-    async writeAgentConfig(config, scope, baseline) {
-        const settingsPath = scope === 'project'
-            ? join(process.cwd(), '.claude', 'settings.json')
-            : join(homedir(), '.claude', 'settings.json');
-        const hadFile = existsSync(settingsPath);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let settings = {};
-        if (hadFile) {
-            try {
-                settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-            }
-            catch { /* start fresh */ }
-        }
-        // Retro-fix migration: strip the legacy in-array sentinel from any existing
-        // settings, regardless of whether we inject new rules this sync. This is
-        // what removes the broken "# runwork-managed" entry that makes Claude Code
-        // >= 2.1.x print "matches no known tool" on startup.
-        if (settings.permissions && typeof settings.permissions === 'object') {
-            for (const key of ['allow', 'deny']) {
-                const arr = settings.permissions[key];
-                if (Array.isArray(arr)) {
-                    settings.permissions[key] = arr.filter((x) => x !== LEGACY_MANAGED_MARKER);
-                }
-            }
-        }
-        if (config.modelPreference) {
-            settings.model = config.modelPreference;
-        }
-        if (config.permissionRules) {
-            if (!settings.permissions)
-                settings.permissions = {};
-            const perms = settings.permissions;
-            // Markerless merge: subtract our previous contribution (baseline) to leave
-            // the user's own entries intact, then append the freshly resolved set.
-            if (config.permissionRules.allow) {
-                perms.allow = mergeMarkerless(Array.isArray(perms.allow) ? perms.allow : [], baseline?.allow ?? [], config.permissionRules.allow);
-            }
-            if (config.permissionRules.deny) {
-                perms.deny = mergeMarkerless(Array.isArray(perms.deny) ? perms.deny : [], baseline?.deny ?? [], config.permissionRules.deny);
-            }
-            if (config.permissionRules.defaultMode) {
-                perms.defaultMode = config.permissionRules.defaultMode;
-            }
-        }
-        // Nothing to persist and no file to clean up: avoid creating an empty file.
-        if (!hadFile && !config.modelPreference && !config.permissionRules)
-            return;
-        mkdirSync(join(settingsPath, '..'), { recursive: true });
-        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-    }
-    /**
-     * Markerless adapter: removal detection relies on the `baseline`
-     * (state.lastInjected) passed to writeAgentConfig, exactly like Cursor, since
-     * the adapter no longer writes an on-disk sentinel to delimit its entries.
-     * Returning undefined tells the sync loop to skip on-disk removal detection.
-     */
-    async readManagedBlock(_scope) {
-        return undefined;
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(scope, manifest) {
-        // 1. Remove MCP server entries
-        if (scope === 'project') {
-            removeRunworkMcpServers(join(process.cwd(), '.mcp.json'), 'mcpServers');
-        }
-        else {
-            removeRunworkMcpServers(join(homedir(), '.claude', 'settings.json'), 'mcpServers');
-        }
-        // 2. Remove only skill directories that we synced (listed in manifest)
-        const skillsDir = scope === 'project'
-            ? join(process.cwd(), '.claude', 'skills')
-            : join(homedir(), '.claude', 'skills');
-        if (existsSync(skillsDir) && manifest?.skillFilenames.length) {
-            const allowed = new Set(manifest.skillFilenames);
-            for (const entry of readdirSync(skillsDir)) {
-                if (!allowed.has(entry))
-                    continue;
-                try {
-                    rmSync(join(skillsDir, entry), { recursive: true, force: true });
-                }
-                catch { /* best-effort */ }
-            }
-        }
-        // 3. Remove instruction hints and team instructions
-        const instructionFile = scope === 'project'
-            ? join(process.cwd(), '.claude', 'CLAUDE.md')
-            : join(homedir(), '.claude', 'CLAUDE.md');
-        removeHintFromFile(instructionFile);
-        removeTeamInstructionsFromFile(instructionFile);
-        // 4. Remove agent config overrides (managed permission entries, model, enabledPlugins)
-        if (scope === 'user') {
-            const settingsPath = join(homedir(), '.claude', 'settings.json');
-            if (existsSync(settingsPath)) {
-                try {
-                    const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-                    // Remove managed permission entries. Legacy installs carry the
-                    // in-array marker, so everything from the marker onward is ours.
-                    // Always also drop any stray marker so uninstall never leaves the
-                    // entry that breaks Claude Code startup.
-                    if (settings.permissions) {
-                        for (const key of ['allow', 'deny']) {
-                            const arr = settings.permissions[key];
-                            if (!Array.isArray(arr))
-                                continue;
-                            const idx = arr.indexOf(LEGACY_MANAGED_MARKER);
-                            settings.permissions[key] = (idx >= 0 ? arr.slice(0, idx) : arr)
-                                .filter((x) => x !== LEGACY_MANAGED_MARKER);
-                        }
-                    }
-                    // Remove plugin enablement
-                    if (settings.enabledPlugins) {
-                        delete settings.enabledPlugins[`${PLUGIN_NAME}@runwork`];
-                    }
-                    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-                }
-                catch { /* best-effort */ }
-            }
-            // 5. Remove plugin directories
-            const pluginDir = this.getPluginDir();
-            const marketRoot = this.getMarketplaceRoot();
-            for (const dir of [pluginDir, marketRoot]) {
-                if (existsSync(dir)) {
-                    try {
-                        rmSync(dir, { recursive: true, force: true });
-                    }
-                    catch { /* best-effort */ }
-                }
-            }
-            // 6. Remove from installed_plugins.json
-            const pluginsBase = this.getPluginsBaseDir();
-            const installedPath = join(pluginsBase, 'installed_plugins.json');
-            if (existsSync(installedPath)) {
-                try {
-                    const installed = readJsonConfig(installedPath);
-                    if (installed.plugins) {
-                        delete installed.plugins[`${PLUGIN_NAME}@runwork`];
-                        writeJsonConfig(installedPath, installed);
-                    }
-                }
-                catch { /* best-effort */ }
-            }
-            // 7. Remove from known_marketplaces.json
-            const marketplacesPath = join(pluginsBase, 'known_marketplaces.json');
-            if (existsSync(marketplacesPath)) {
-                try {
-                    const marketplaces = readJsonConfig(marketplacesPath);
-                    delete marketplaces['runwork'];
-                    writeJsonConfig(marketplacesPath, marketplaces);
-                }
-                catch { /* best-effort */ }
-            }
-        }
-    }
-    // ── Usage stats (passive, best-effort) ─────────────────────────────
-    async readUsageStats(lastSyncAt) {
-        // Source of truth: ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl
-        // Each line is one user/assistant/system entry. The file grows continuously
-        // during a live session, so mtime + per-entry timestamp give an accurate
-        // post-sync activity picture. (stats-cache.json was abandoned upstream and
-        // session-env/ only records session-start hooks.)
-        try {
-            const claudeDir = join(homedir(), '.claude');
-            if (!existsSync(claudeDir))
-                return null;
-            const projectsDir = join(claudeDir, 'projects');
-            if (!existsSync(projectsDir))
-                return null;
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            let sessionCount = 0;
-            let messageCount = 0;
-            let toolCallCount = 0;
-            let inputTokens = 0;
-            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);
-            }
-            catch {
-                return null;
-            }
-            for (const cwd of cwdEntries) {
-                const cwdPath = join(projectsDir, cwd);
-                let files;
-                try {
-                    files = readdirSync(cwdPath);
-                }
-                catch {
-                    continue;
-                }
-                for (const file of files) {
-                    if (!file.endsWith('.jsonl'))
-                        continue;
-                    const filePath = join(cwdPath, file);
-                    let stat;
-                    try {
-                        stat = statSync(filePath);
-                    }
-                    catch {
-                        continue;
-                    }
-                    if (stat.mtimeMs <= sinceMs)
-                        continue;
-                    let content;
-                    try {
-                        content = readFileSync(filePath, 'utf-8');
-                    }
-                    catch {
-                        continue;
-                    }
-                    let sessionHadActivity = false;
-                    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;
-                        sessionHadActivity = true;
-                        if (ts > latestActivityMs)
-                            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') {
-                            const msg = entry.message;
-                            if (msg && typeof msg === 'object') {
-                                const msgRecord = msg;
-                                const blocks = Array.isArray(msgRecord.content) ? msgRecord.content : [];
-                                for (const block of blocks) {
-                                    if (block && typeof block === 'object'
-                                        && block.type === 'tool_use') {
-                                        toolCallCount++;
-                                    }
-                                }
-                                const usage = msgRecord.usage;
-                                if (usage && typeof usage === 'object') {
-                                    const u = usage;
-                                    if (typeof u.input_tokens === 'number')
-                                        inputTokens += u.input_tokens;
-                                    if (typeof u.output_tokens === 'number')
-                                        outputTokens += u.output_tokens;
-                                    if (typeof u.cache_read_input_tokens === 'number') {
-                                        cacheReadTokens += u.cache_read_input_tokens;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (sessionHadActivity)
-                        sessionCount++;
-                }
-            }
-            if (sessionCount === 0)
-                return null;
-            return {
-                hasNewActivity: true,
-                sessionCount,
-                messageCount,
-                toolCallCount,
-                tokensUsed: inputTokens + outputTokens,
-                aiLinesAdded: 0,
-                aiLinesRemoved: 0,
-                lastActiveAt: latestActivityMs > 0 ? new Date(latestActivityMs).toISOString() : null,
-                extra: { inputTokens, outputTokens, cacheReadTokens },
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    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 projectsDir = join(homedir(), '.claude', 'projects');
-            if (!existsSync(projectsDir))
-                return null;
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            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 file of files) {
-                    if (!file.endsWith('.jsonl'))
-                        continue;
-                    const filePath = join(cwdPath, file);
-                    let fileStat;
-                    try {
-                        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 };
-                            }
-                        }
-                    }
-                }
-            }
-            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;
-        }
-    }
-    async readVersion() {
-        try {
-            const output = execFileSync('claude', ['--version'], { stdio: 'pipe' }).toString().trim();
-            return output;
-        }
-        catch {
-            return null;
-        }
-    }
-    // ── Plugin helpers ─────────────────────────────────────────────────
-    getPluginsBaseDir() {
-        return join(homedir(), '.claude', 'plugins');
-    }
-    getPluginDir() {
-        return join(this.getPluginsBaseDir(), 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
-    }
-    /** The marketplace root (contains marketplace.json and plugins/) */
-    getMarketplaceRoot() {
-        return join(this.getPluginsBaseDir(), 'marketplaces', 'runwork');
-    }
-    /** The plugin directory within the marketplace */
-    getMarketplaceDir() {
-        return join(this.getMarketplaceRoot(), 'plugins', PLUGIN_NAME);
-    }
-    registerPlugin(pluginDir) {
-        const pluginsBase = this.getPluginsBaseDir();
-        mkdirSync(pluginsBase, { recursive: true });
-        // Register in installed_plugins.json
-        const installedPath = join(pluginsBase, 'installed_plugins.json');
-        const installed = readJsonConfig(installedPath);
-        if (!installed.version)
-            installed.version = 2;
-        if (!installed.plugins)
-            installed.plugins = {};
-        const pluginKey = `${PLUGIN_NAME}@runwork`;
-        const wasRegistered = !!installed.plugins[pluginKey];
-        installed.plugins[pluginKey] = [{
-                scope: 'user',
-                installPath: pluginDir,
-                version: PLUGIN_VERSION,
-                installedAt: new Date().toISOString(),
-                lastUpdated: new Date().toISOString(),
-            }];
-        writeJsonConfig(installedPath, installed);
-        // Write marketplace.json catalog
-        const marketRoot = this.getMarketplaceRoot();
-        const marketCatalogDir = join(marketRoot, '.claude-plugin');
-        mkdirSync(marketCatalogDir, { recursive: true });
-        writeFileSync(join(marketCatalogDir, 'marketplace.json'), JSON.stringify(getMarketplaceJson(), null, 2));
-        // Register in known_marketplaces.json
-        const marketplacesPath = join(pluginsBase, 'known_marketplaces.json');
-        const marketplaces = readJsonConfig(marketplacesPath);
-        marketplaces['runwork'] = {
-            source: { source: 'directory', path: marketRoot },
-            installLocation: marketRoot,
-            lastUpdated: new Date().toISOString(),
-        };
-        writeJsonConfig(marketplacesPath, marketplaces);
-        console.log(`  [Claude Code] ${wasRegistered ? 'Refreshed' : 'Registered'} plugin ` +
-            `${pluginKey} v${PLUGIN_VERSION} -> ${installedPath}`);
-        // Enable the plugin in settings.json
-        const settingsPath = join(homedir(), '.claude', 'settings.json');
-        const settings = readJsonConfig(settingsPath);
-        if (!settings['enabledPlugins']) {
-            settings['enabledPlugins'] = {};
-        }
-        const enabled = settings['enabledPlugins'];
-        if (!enabled[`${PLUGIN_NAME}@runwork`]) {
-            enabled[`${PLUGIN_NAME}@runwork`] = true;
-            writeJsonConfig(settingsPath, settings);
-        }
-    }
-}
-/**
- * Remove old skill directory that used the display name (with spaces) if it
- * differs from the new slug-based directory name.
- */
-function cleanupOldSkillDir(baseDir, skill) {
-    if (skill.name === skill.filename)
-        return;
-    const oldDir = join(baseDir, skill.name);
-    if (existsSync(oldDir)) {
-        try {
-            rmSync(oldDir, { recursive: true, force: true });
-        }
-        catch { /* best-effort */ }
-    }
-}