runwork 0.15.0 → 0.15.2

package/dist/agents/cline.d.ts

@@ -1,15 +0,0 @@
-import type { AgentAdapter, AgentConfigOverride, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
-export declare class ClineAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    detect(): Promise<boolean>;
-    supportsMcpScope(scope: 'project' | 'user'): boolean;
-    supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
-    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
-    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
-    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
-    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-}

package/dist/agents/cline.js

@@ -1,130 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { whichBinary } from '../utils/which.js';
-import { buildSkillMd } from './types.js';
-import { mergeJsonMcpServers, removeRunworkMcpServers } from './utils/json-config.js';
-export class ClineAdapter {
-    name = 'Cline';
-    slug = 'cline';
-    mcpProvidesSkills = true;
-    async detect() {
-        return !!whichBinary('cline');
-    }
-    supportsMcpScope(scope) {
-        return scope === 'user';
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, _scope) {
-        const configPath = join(homedir(), '.cline', 'data', 'settings', 'cline_mcp_settings.json');
-        const entries = {};
-        for (const s of servers) {
-            entries[s.name] = {
-                url: s.url,
-                ...(s.headers ? { headers: s.headers } : {}),
-            };
-        }
-        mergeJsonMcpServers(configPath, entries, 'mcpServers');
-    }
-    async writeSkills(skills, scope) {
-        if (scope === 'user')
-            return;
-        const rulesDir = join(process.cwd(), '.clinerules');
-        mkdirSync(rulesDir, { recursive: true });
-        for (const skill of skills) {
-            writeFileSync(join(rulesDir, `${skill.filename}.md`), buildSkillMd(skill));
-        }
-    }
-    async writeInstructionHint(hint, scope) {
-        if (scope === 'user')
-            return;
-        const filePath = join(process.cwd(), '.clinerules', 'runwork.md');
-        mkdirSync(join(filePath, '..'), { recursive: true });
-        writeFileSync(filePath, hint);
-    }
-    async writeTeamInstructions(instructions, scope) {
-        if (scope === 'user')
-            return;
-        const filePath = join(process.cwd(), '.clinerules', 'runwork-team.md');
-        mkdirSync(join(filePath, '..'), { recursive: true });
-        writeFileSync(filePath, instructions);
-    }
-    // ── Agent config (globalState.json) ────────────────────────────────
-    async writeAgentConfig(config, scope) {
-        if (scope !== 'user')
-            return;
-        const globalStatePath = join(homedir(), '.cline', 'data', 'globalState.json');
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let state = {};
-        if (existsSync(globalStatePath)) {
-            try {
-                state = JSON.parse(readFileSync(globalStatePath, 'utf-8'));
-            }
-            catch { /* start fresh */ }
-        }
-        if (config.modelPreference) {
-            state.apiModelId = config.modelPreference;
-        }
-        if (config.permissionRules) {
-            if (!state.autoApprovalSettings)
-                state.autoApprovalSettings = {};
-            if (!state.autoApprovalSettings.actions)
-                state.autoApprovalSettings.actions = {};
-            if (config.permissionRules.defaultMode === 'auto') {
-                state.autoApprovalSettings.enabled = true;
-                state.autoApprovalSettings.actions.readFiles = true;
-                state.autoApprovalSettings.actions.editFiles = true;
-                state.autoApprovalSettings.actions.executeSafeCommands = true;
-                state.autoApprovalSettings.actions.useMcp = true;
-            }
-            else if (config.permissionRules.defaultMode === 'default') {
-                state.autoApprovalSettings.enabled = false;
-            }
-        }
-        mkdirSync(join(globalStatePath, '..'), { recursive: true });
-        writeFileSync(globalStatePath, JSON.stringify(state, null, 2));
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(scope, manifest) {
-        // 1. Remove MCP entries (user scope only)
-        if (scope === 'user') {
-            const configPath = join(homedir(), '.cline', 'data', 'settings', 'cline_mcp_settings.json');
-            removeRunworkMcpServers(configPath, 'mcpServers');
-        }
-        // 2. Remove rule files (project scope only)
-        if (scope === 'project') {
-            const rulesDir = join(process.cwd(), '.clinerules');
-            if (existsSync(rulesDir)) {
-                for (const file of ['runwork.md', 'runwork-team.md']) {
-                    const filePath = join(rulesDir, file);
-                    if (existsSync(filePath)) {
-                        try {
-                            unlinkSync(filePath);
-                        }
-                        catch { /* best-effort */ }
-                    }
-                }
-                // Remove only skill .md files that we synced
-                if (manifest?.skillFilenames.length) {
-                    const allowed = new Set(manifest.skillFilenames.map(f => `${f}.md`));
-                    for (const entry of readdirSync(rulesDir)) {
-                        if (allowed.has(entry)) {
-                            try {
-                                unlinkSync(join(rulesDir, entry));
-                            }
-                            catch { /* best-effort */ }
-                        }
-                    }
-                }
-                // Remove dir if empty
-                try {
-                    if (readdirSync(rulesDir).length === 0)
-                        rmSync(rulesDir, { recursive: true });
-                }
-                catch { /* best-effort */ }
-            }
-        }
-    }
-}

package/dist/agents/codex.d.ts

@@ -1,44 +0,0 @@
-import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
-export declare class CodexAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    detect(): Promise<boolean>;
-    supportsMcpScope(_scope: 'project' | 'user'): boolean;
-    supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
-    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
-    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
-    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
-    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>;
-}

package/dist/agents/codex.js

@@ -1,453 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { parse, stringify } from 'smol-toml';
-import { buildSkillMd, appendTokenToUrl, RUNWORK_WORKSPACE_MCP_NAME } from './types.js';
-function isRunworkManagedCodexKey(key) {
-    return (key === RUNWORK_WORKSPACE_MCP_NAME ||
-        key.startsWith('runwork-') ||
-        key.startsWith('Runwork-'));
-}
-import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
-import { querySqlite } from '../utils/sqlite.js';
-import { whichBinary, isAppRunning } from '../utils/which.js';
-import { runAgentDetection } from './detection.js';
-import { getRegistryAgent } from './registry.js';
-export class CodexAdapter {
-    name = 'Codex';
-    slug = 'codex';
-    mcpProvidesSkills = true;
-    async detect() {
-        return !!whichBinary('codex');
-    }
-    supportsMcpScope(_scope) {
-        return true;
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, _scope) {
-        // Codex uses config.toml with [mcp_servers.*] sections
-        const configPath = join(homedir(), '.codex', 'config.toml');
-        let parsed = {};
-        if (existsSync(configPath)) {
-            parsed = parse(readFileSync(configPath, 'utf-8'));
-        }
-        if (!parsed.mcp_servers || typeof parsed.mcp_servers !== 'object') {
-            parsed.mcp_servers = {};
-        }
-        const mcpServers = parsed.mcp_servers;
-        // Remove existing runwork-managed entries. Handles legacy lowercase
-        // ("runwork-foo"), sanitized PascalCase ("Runwork-foo"), and the bare
-        // workspace-tools name ("Runwork").
-        for (const key of Object.keys(mcpServers)) {
-            if (isRunworkManagedCodexKey(key)) {
-                delete mcpServers[key];
-            }
-        }
-        // Add new entries (sanitize names to match Codex's ^[a-zA-Z0-9_-]+$ requirement).
-        for (const s of servers) {
-            const safeName = s.name.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
-            const entry = { url: s.url };
-            if (s.name === RUNWORK_WORKSPACE_MCP_NAME) {
-                // Preserve the known-working behavior: embed the workspace key in the URL.
-                // Codex's header-based auth was historically unreliable here, so do NOT change it.
-                const token = s.headers?.Authorization?.replace(/^Bearer\s+/i, '');
-                if (token)
-                    entry.url = appendTokenToUrl(s.url, token);
-            }
-            else if (s.headers && Object.keys(s.headers).length > 0) {
-                // External servers: forward headers via Codex's documented http_headers field
-                // (static literal values). These had no prior working path, so this is additive.
-                entry.http_headers = s.headers;
-            }
-            mcpServers[safeName] = entry;
-        }
-        mkdirSync(join(configPath, '..'), { recursive: true });
-        writeFileSync(configPath, stringify(parsed));
-    }
-    async writeSkills(skills, scope) {
-        const baseDir = scope === 'project'
-            ? join(process.cwd(), '.codex', 'skills')
-            : join(homedir(), '.codex', 'skills');
-        for (const skill of skills) {
-            if (skill.name !== skill.filename) {
-                const oldDir = join(baseDir, skill.name);
-                if (existsSync(oldDir)) {
-                    try {
-                        rmSync(oldDir, { recursive: true, force: true });
-                    }
-                    catch { /* best-effort */ }
-                }
-            }
-            const skillDir = join(baseDir, skill.filename);
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
-        }
-    }
-    async writeInstructionHint(hint, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), 'AGENTS.md')
-            : join(homedir(), '.codex', 'AGENTS.md');
-        writeHintToFile(filePath, hint);
-    }
-    async writeTeamInstructions(instructions, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), 'AGENTS.md')
-            : join(homedir(), '.codex', 'AGENTS.md');
-        writeTeamInstructionsToFile(filePath, instructions);
-    }
-    // ── Agent config (TOML) ───────────────────────────────────────────
-    async writeAgentConfig(config, scope) {
-        const configPath = scope === 'project'
-            ? join(process.cwd(), '.codex', 'config.toml')
-            : join(homedir(), '.codex', 'config.toml');
-        let parsed = {};
-        if (existsSync(configPath)) {
-            parsed = parse(readFileSync(configPath, 'utf-8'));
-        }
-        if (config.modelPreference) {
-            parsed.model = config.modelPreference;
-        }
-        if (config.permissionRules?.defaultMode) {
-            const modeMap = {
-                auto: 'never',
-                default: 'on-request',
-                plan: 'untrusted',
-            };
-            parsed.approval_policy = modeMap[config.permissionRules.defaultMode] ?? config.permissionRules.defaultMode;
-        }
-        // Apply minimum permission floors: only upgrade, never downgrade
-        if (config.minimumPermissions) {
-            for (const { field, order, minimum } of config.minimumPermissions) {
-                const current = typeof parsed[field] === 'string' ? parsed[field] : '';
-                const currentIdx = order.indexOf(current);
-                const minimumIdx = order.indexOf(minimum);
-                // Upgrade if current is unknown (not in order) or more restrictive than minimum
-                if (currentIdx < minimumIdx) {
-                    parsed[field] = minimum;
-                }
-            }
-        }
-        mkdirSync(join(configPath, '..'), { recursive: true });
-        writeFileSync(configPath, stringify(parsed));
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(scope, manifest) {
-        // 1. Remove MCP server entries from config.toml
-        const configPath = join(homedir(), '.codex', 'config.toml');
-        if (existsSync(configPath)) {
-            try {
-                const parsed = parse(readFileSync(configPath, 'utf-8'));
-                if (parsed.mcp_servers && typeof parsed.mcp_servers === 'object') {
-                    const mcpServers = parsed.mcp_servers;
-                    for (const key of Object.keys(mcpServers)) {
-                        // Codex TOML sanitizes names via writeMcpServers, so the JSON-style
-                        // "Runwork: " prefix is never actually written here. Match the real
-                        // on-disk forms: "runwork-*" (legacy), "Runwork-*" (previous), and
-                        // the bare "Runwork" name used for workspace tools.
-                        if (isRunworkManagedCodexKey(key)) {
-                            delete mcpServers[key];
-                        }
-                    }
-                }
-                writeFileSync(configPath, stringify(parsed));
-            }
-            catch { /* best-effort */ }
-        }
-        // 2. Remove only skill directories that we synced (listed in manifest)
-        const skillsDir = scope === 'project'
-            ? join(process.cwd(), '.codex', 'skills')
-            : join(homedir(), '.codex', '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(), 'AGENTS.md')
-            : join(homedir(), '.codex', 'AGENTS.md');
-        removeHintFromFile(instructionFile);
-        removeTeamInstructionsFromFile(instructionFile);
-    }
-    // ── Usage stats (passive, best-effort) ─────────────────────────────
-    async readUsageStats(lastSyncAt) {
-        try {
-            const codexDir = join(homedir(), '.codex');
-            if (!existsSync(codexDir))
-                return null;
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            const sinceSec = Math.floor(sinceMs / 1000);
-            const dbPath = join(codexDir, 'state_5.sqlite');
-            if (!existsSync(dbPath))
-                return null;
-            // Filter on updated_at, not created_at: long-lived threads can accumulate
-            // activity post-sync without ever being "newly created". tokens_used is a
-            // lifetime per-thread total — summing active threads here overcounts when
-            // a thread was already partially used before lastSyncAt, but it's a far
-            // better signal than "0 because no new threads were spawned".
-            const countResult = querySqlite(dbPath, `SELECT count(*) FROM threads WHERE updated_at > ${sinceSec}`);
-            const sessionCount = parseInt(countResult) || 0;
-            const tokensResult = querySqlite(dbPath, `SELECT coalesce(sum(tokens_used), 0) FROM threads WHERE updated_at > ${sinceSec}`);
-            const tokensUsed = parseInt(tokensResult) || 0;
-            const latestResult = querySqlite(dbPath, `SELECT max(updated_at) FROM threads`);
-            const latestSec = parseInt(latestResult) || 0;
-            const versionsResult = querySqlite(dbPath, `SELECT DISTINCT cli_version FROM threads WHERE cli_version IS NOT NULL ORDER BY created_at DESC LIMIT 3`);
-            const versions = versionsResult ? versionsResult.split(/[\r\n]+/).filter(Boolean) : [];
-            let messageCount = 0;
-            const historyPath = join(codexDir, 'history.jsonl');
-            if (existsSync(historyPath)) {
-                const content = readFileSync(historyPath, 'utf-8').trim();
-                if (content) {
-                    for (const line of content.split(/[\r\n]+/)) {
-                        try {
-                            const entry = JSON.parse(line);
-                            if (entry.ts && entry.ts > sinceSec)
-                                messageCount++;
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-            }
-            if (sessionCount === 0 && (latestSec * 1000) <= sinceMs)
-                return null;
-            return {
-                hasNewActivity: sessionCount > 0,
-                sessionCount,
-                messageCount,
-                toolCallCount: 0,
-                tokensUsed,
-                aiLinesAdded: 0,
-                aiLinesRemoved: 0,
-                lastActiveAt: latestSec > 0 ? new Date(latestSec * 1000).toISOString() : null,
-                extra: versions.length > 0 ? { cliVersions: versions } : undefined,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    async readVersion() {
-        try {
-            const versionPath = join(homedir(), '.codex', 'version.json');
-            if (existsSync(versionPath)) {
-                const data = JSON.parse(readFileSync(versionPath, 'utf-8'));
-                return data.latest_version ?? null;
-            }
-        }
-        catch { /* best-effort */ }
-        return null;
-    }
-    async readSkillUsage(lastSyncAt) {
-        // Codex rollout JSONL files contain a session_meta entry whose
-        // `instructions` field lists all skills available in the session.
-        // Skills appear as "- name: description (file: path/SKILL.md)".
-        // This gives us reach data (which skills were loaded), not invocation.
-        //
-        // Rollout files live at ~/.codex/sessions/<year>/<month>/<day>/rollout-*.jsonl
-        // and are linked from the threads table via rollout_path.
-        try {
-            const sessionsDir = join(homedir(), '.codex', 'sessions');
-            if (!existsSync(sessionsDir))
-                return null;
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            const skillCounts = new Map();
-            // Walk session directories by year/month/day
-            const walkDir = (dir) => {
-                let entries;
-                try {
-                    entries = readdirSync(dir);
-                }
-                catch {
-                    return;
-                }
-                for (const entry of entries) {
-                    const fullPath = join(dir, entry);
-                    if (entry.endsWith('.jsonl')) {
-                        let fileStat;
-                        try {
-                            fileStat = statSync(fullPath);
-                        }
-                        catch {
-                            continue;
-                        }
-                        if (fileStat.mtimeMs <= sinceMs)
-                            continue;
-                        this.parseRolloutForSkills(fullPath, sinceMs, skillCounts);
-                    }
-                    else {
-                        // Recurse into year/month/day subdirectories
-                        try {
-                            if (statSync(fullPath).isDirectory())
-                                walkDir(fullPath);
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-            };
-            walkDir(sessionsDir);
-            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;
-        }
-    }
-    /** Parse a rollout JSONL file for skill data */
-    parseRolloutForSkills(filePath, sinceMs, skillCounts) {
-        let content;
-        try {
-            content = readFileSync(filePath, 'utf-8');
-        }
-        catch {
-            return;
-        }
-        for (const line of content.split('\n')) {
-            if (!line)
-                continue;
-            let entry;
-            try {
-                entry = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (entry.type !== 'session_meta')
-                continue;
-            const payload = entry.payload;
-            if (!payload)
-                continue;
-            const tsRaw = entry.timestamp;
-            const ts = typeof tsRaw === 'string' ? Date.parse(tsRaw) : 0;
-            if (ts <= sinceMs)
-                continue;
-            const instructions = payload.instructions;
-            if (typeof instructions !== 'string')
-                continue;
-            // Parse "- name: description (file: path/SKILL.md)" entries from the
-            // "### Available skills" section. Skip Codex's built-in system skills
-            // (those installed under `.system/`, e.g. skill-creator,
-            // skill-installer) since they are bundled with the agent and would
-            // skew adoption metrics meant to track *user-installed* skills.
-            const skillRegex = /^- ([^:]+):\s+.+\(file:\s+(.+\/SKILL\.md)\)/gm;
-            let match;
-            while ((match = skillRegex.exec(instructions)) !== null) {
-                const skillName = match[1].trim();
-                const skillPath = match[2];
-                if (skillPath.includes('/.system/'))
-                    continue;
-                const existing = skillCounts.get(skillName);
-                if (existing) {
-                    existing.count++;
-                    if (ts > existing.lastTs)
-                        existing.lastTs = ts;
-                }
-                else {
-                    skillCounts.set(skillName, { count: 1, lastTs: ts });
-                }
-            }
-            // Only process the first session_meta per file
-            break;
-        }
-    }
-    // ── Codex Desktop app workspace registration ──────────────────────
-    /**
-     * 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, label) {
-        const statePath = join(homedir(), '.codex', '.codex-global-state.json');
-        // Read current state (or start fresh if file doesn't exist)
-        let state = {};
-        if (existsSync(statePath)) {
-            try {
-                state = JSON.parse(readFileSync(statePath, 'utf-8'));
-            }
-            catch {
-                return 'app_running'; // corrupt file, don't touch
-            }
-        }
-        // Check if already registered in all required keys
-        const savedRoots = (Array.isArray(state['electron-saved-workspace-roots'])
-            ? state['electron-saved-workspace-roots'] : []);
-        const projectOrder = (Array.isArray(state['project-order'])
-            ? state['project-order'] : []);
-        const labels = (state['electron-workspace-root-labels'] && typeof state['electron-workspace-root-labels'] === 'object'
-            ? state['electron-workspace-root-labels'] : {});
-        const inSaved = savedRoots.includes(workspacePath);
-        const inOrder = projectOrder.includes(workspacePath);
-        const inLabels = labels[workspacePath] === label;
-        if (inSaved && inOrder && inLabels) {
-            return 'already_registered';
-        }
-        // Codex desktop app holds this file in memory and overwrites on any state
-        // change. Writing while it's open is futile. Check if it's running.
-        if (isAppRunning('Codex')) {
-            return 'app_running';
-        }
-        // Merge our workspace into the state
-        if (!inSaved) {
-            savedRoots.push(workspacePath);
-            state['electron-saved-workspace-roots'] = savedRoots;
-        }
-        if (!inOrder) {
-            projectOrder.push(workspacePath);
-            state['project-order'] = projectOrder;
-        }
-        labels[workspacePath] = label;
-        state['electron-workspace-root-labels'] = labels;
-        mkdirSync(join(statePath, '..'), { recursive: true });
-        writeFileSync(statePath, JSON.stringify(state));
-        return 'written';
-    }
-}
-/**
- * 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 class CodexDesktopAdapter extends CodexAdapter {
-    name = 'Codex';
-    slug = 'codex-app';
-    async detect() {
-        const def = getRegistryAgent('codex-app');
-        if (!def)
-            return false;
-        return runAgentDetection(def.detection);
-    }
-    // Usage stats come from ~/.codex/state_5.sqlite, which is shared between
-    // Codex CLI and Codex Desktop. Leaving the read here would double-count
-    // sessions/tokens whenever both adapters are detected on the same machine.
-    // Defer to CodexAdapter (slug 'codex') as the sole source of Codex stats.
-    async readUsageStats() {
-        return null;
-    }
-}

package/dist/agents/conversation-skills.d.ts

@@ -1,18 +0,0 @@
-import type { SkillFile } from './types.js';
-/**
- * Names of every skill the CLI ships as a built-in (written to user machines
- * on each sync from code, never pulled from or pushed to the workspace).
- *
- * Sync uses this list to:
- *   1. Skip these names when computing the local-vs-remote diff so they
- *      never appear in pull/push/conflict plans.
- *   2. Warn the user (and offer cleanup) if a workspace skill with the same
- *      name exists -- it would be shadowed by the built-in locally and is
- *      probably a stale duplicate.
- *
- * Keep this list in sync with: intro-skill.ts (`runwork`) and the two
- * `buildXConversationSkill` functions below.
- */
-export declare const BUILT_IN_SKILL_NAMES: ReadonlyArray<string>;
-export declare function buildShareConversationSkill(): SkillFile;
-export declare function buildSaveConversationSkill(): SkillFile;