@reeledge/agent-tools 0.1.4 → 0.1.7

package/dist/apps/claude-code.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { claudeMcpAddArgs, mcpEndpoint } from '../mcp.js';
 import { writeSkillTree } from '../skills.js';
+import { buildLocalPlugin, claudePluginDir, pluginDryRunLines, registerAndInstallPlugin, } from './claude-plugin.js';
 import { APP_LABELS, CONNECTOR_NAME, } from './types.js';
 /** Resolve the skills dir: explicit override, else `~/.claude/skills`. */
 function claudeSkillsDir(env) {
@@ -70,29 +71,63 @@ export function makeClaudeCodeAdapter(env) {
     const platform = () => env.platform ?? process.platform;
     const log = (line) => env.log?.(line);
     const desktopPath = () => claudeDesktopConfigPath(env.homeDir, platform());
+    const pluginDir = () => claudePluginDir();
+    // Captured by `writeSkills` so `configureMcp` can fall back to a loose
+    // `~/.claude/skills/` write when the `claude` binary is absent (and the plugin
+    // therefore can't be installed). In the real flow `writeSkills` always runs
+    // first (install.ts); left `[]` the fallback simply writes nothing.
+    let pending = [];
     return {
         id: 'claude-code',
         label: APP_LABELS['claude-code'],
         skillsDir,
         writeSkills(skills) {
-            return skills.flatMap((s) => writeSkillTree(skillsDir(), s.slug, s.files));
+            pending = skills;
+            // Build the self-contained local plugin — the primary skills path. The
+            // actual register/install (and any loose-skills fallback) happens in
+            // `configureMcp`, which can await the `claude` CLI.
+            return buildLocalPlugin(pluginDir(), skills);
         },
         async configureMcp(serverUrl, token) {
-            // 1. Claude Code CLI — best-effort and FULLY ISOLATED: a CLI failure must
-            //    never block the desktop step below. A spawn ENOENT = not installed;
-            //    "already exists" (a re-run / `update`, exit 1) or any other failure is
-            //    logged as skipped, NOT thrown — the connector is already in place, and
-            //    the desktop bridge still gets written.
+            // 1. Claude Code CLI MCP connector — best-effort and FULLY ISOLATED: a CLI
+            //    failure must never block the plugin/desktop steps below. A spawn ENOENT
+            //    = not installed; "already exists" (a re-run / `update`, exit 1) or any
+            //    other failure is logged as skipped, NOT thrown.
+            let claudeMissing = false;
             try {
                 await env.exec('claude', claudeMcpAddArgs(CONNECTOR_NAME, serverUrl, token));
                 log(`Configured Claude Code CLI (${CONNECTOR_NAME})`);
             }
             catch (err) {
-                log(err.code === 'ENOENT'
-                    ? 'Claude Code CLI not found — skipped'
-                    : `Claude Code CLI not configured — skipped (${err.message})`);
+                if (err.code === 'ENOENT') {
+                    claudeMissing = true;
+                    log('Claude Code CLI not found — skipped');
+                }
+                else {
+                    log(`Claude Code CLI not configured — skipped (${err.message})`);
+                }
+            }
+            // 2. Skills plugin — register the local marketplace + install the plugin so
+            //    it auto-loads in the Claude Code CLI AND the Desktop app. If `claude`
+            //    is absent, fall back to a loose `~/.claude/skills/` write so the CLI
+            //    still gets the skills.
+            if (!claudeMissing) {
+                const { claudeFound } = await registerAndInstallPlugin(env.exec, pluginDir());
+                if (claudeFound) {
+                    log('Installed skills plugin (auto-loads in Claude Code + Desktop)');
+                }
+                else {
+                    claudeMissing = true;
+                }
+            }
+            if (claudeMissing && pending.length > 0) {
+                const written = pending.flatMap((s) => writeSkillTree(skillsDir(), s.slug, s.files));
+                for (const file of written)
+                    log(`  wrote ${file}`);
+                log('Claude CLI unavailable — wrote skills to ~/.claude/skills (Claude Code only)');
             }
-            // 2. Claude Desktop — macOS/Windows only; ALWAYS runs, independent of the CLI.
+            // 3. Claude Desktop MCP bridge — macOS/Windows only; ALWAYS runs, independent
+            //    of the CLI (skills reach Desktop via the plugin, above).
             const cfgPath = desktopPath();
             if (cfgPath !== null) {
                 const entry = claudeDesktopEntry(mcpEndpoint(serverUrl), token);
@@ -104,14 +139,12 @@ export function makeClaudeCodeAdapter(env) {
             }
         },
         dryRunPlan(serverUrl, token, skills) {
-            const lines = [];
-            for (const s of skills) {
-                for (const file of s.files) {
-                    lines.push(`would write ${path.join(skillsDir(), s.slug, file.path)}`);
-                }
-            }
+            // Skills plugin build + register/install.
+            const lines = pluginDryRunLines(pluginDir(), skills);
+            // MCP connector.
             const args = claudeMcpAddArgs(CONNECTOR_NAME, serverUrl, token);
             lines.push(`would run: claude ${args.join(' ')}`);
+            // Desktop bridge.
             const cfgPath = desktopPath();
             if (cfgPath !== null) {
                 const entry = claudeDesktopEntry(mcpEndpoint(serverUrl), token);

package/dist/apps/claude-plugin.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configDir } from '../config.js';
+import { writeSkillTree } from '../skills.js';
+/**
+ * Self-contained local Claude Code **plugin** built from the fetched skills, then
+ * registered + installed via the `claude` CLI. This is the primary skills path
+ * for Claude Code: a plugin installed into the shared `~/.claude/plugins/`
+ * registry auto-loads in BOTH the Claude Code **CLI** and the Claude **Desktop**
+ * app (Desktop shares that registry — the loose `~/.claude/skills/` directory is
+ * NOT read by Desktop), with zero manual steps and no GitHub-repo access.
+ *
+ * The plugin is fully self-contained (no symlinks, no remote source): a
+ * `marketplace.json` with one plugin whose `source` is `"./"` (the marketplace
+ * root IS the plugin), a `plugin.json`, and the skill trees under `skills/`.
+ */
+/** Marketplace `name` — how the plugin is referenced (`<plugin>@<marketplace>`). */
+export const MARKETPLACE_NAME = 'reel-edge';
+/** Plugin `name` — becomes the skill namespace (`reel-edge-skills:<skill>`). */
+export const PLUGIN_NAME = 'reel-edge-skills';
+/** Plugin version — bump to push skill-content updates to installed users. */
+export const PLUGIN_VERSION = '1.0.0';
+/** `<plugin>@<marketplace>` reference used by `claude plugin install`. */
+export const PLUGIN_REF = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+/** Clean, user-facing description shared by the marketplace entry + plugin.json. */
+const PLUGIN_DESCRIPTION = 'Read-only domain skills for the Reel Edge MCP server: Reel Explorer (Xano ' +
+    'database query guide), Inbox Scout (player emails), and HubSpot CRM.';
+/**
+ * Absolute directory of the self-contained local plugin. Lives under the CLI's
+ * config home so it's stable across runs and `REELEDGE_CONFIG_DIR`-aware (tests
+ * point it at a temp dir).
+ */
+export function claudePluginDir() {
+    return path.join(configDir(), 'claude-plugin');
+}
+/**
+ * `.claude-plugin/marketplace.json` body: the `reel-edge` marketplace with one
+ * plugin (`reel-edge-skills`) whose `source` is `"./"` — the marketplace root is
+ * the plugin itself, so no external fetch is ever needed.
+ */
+export function marketplaceManifest() {
+    const body = {
+        $schema: 'https://anthropic.com/claude-code/marketplace.schema.json',
+        name: MARKETPLACE_NAME,
+        description: 'Reel Edge agent skills',
+        owner: { name: 'Reel Edge' },
+        plugins: [
+            {
+                name: PLUGIN_NAME,
+                source: './',
+                description: PLUGIN_DESCRIPTION,
+                version: PLUGIN_VERSION,
+                category: 'data',
+            },
+        ],
+    };
+    return `${JSON.stringify(body, null, 2)}\n`;
+}
+/** `.claude-plugin/plugin.json` body for the `reel-edge-skills` plugin. */
+export function pluginManifest() {
+    const body = {
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+        description: PLUGIN_DESCRIPTION,
+    };
+    return `${JSON.stringify(body, null, 2)}\n`;
+}
+/**
+ * Build the self-contained plugin at `dir`:
+ *   dir/.claude-plugin/marketplace.json
+ *   dir/.claude-plugin/plugin.json
+ *   dir/skills/<slug>/SKILL.md (+ references/**)
+ * Returns the written absolute file paths (manifests first, then skill files).
+ * Reuses {@link writeSkillTree}, so the same path-traversal guards apply.
+ */
+export function buildLocalPlugin(dir, skills) {
+    const metaDir = path.join(dir, '.claude-plugin');
+    fs.mkdirSync(metaDir, { recursive: true });
+    const marketplacePath = path.join(metaDir, 'marketplace.json');
+    const pluginPath = path.join(metaDir, 'plugin.json');
+    fs.writeFileSync(marketplacePath, marketplaceManifest(), 'utf8');
+    fs.writeFileSync(pluginPath, pluginManifest(), 'utf8');
+    const written = [marketplacePath, pluginPath];
+    const skillsRoot = path.join(dir, 'skills');
+    for (const s of skills) {
+        written.push(...writeSkillTree(skillsRoot, s.slug, s.files));
+    }
+    return written;
+}
+/** argv for `claude plugin marketplace add <dir> --scope user`. */
+export function marketplaceAddArgs(dir) {
+    return ['plugin', 'marketplace', 'add', dir, '--scope', 'user'];
+}
+/** argv for `claude plugin install reel-edge-skills@reel-edge --scope user`. */
+export function pluginInstallArgs() {
+    return ['plugin', 'install', PLUGIN_REF, '--scope', 'user'];
+}
+/** True for a spawn ENOENT (the `claude` binary isn't on PATH). */
+function isEnoent(err) {
+    return err?.code === 'ENOENT';
+}
+/**
+ * Register the local marketplace + install the plugin at **user scope** via the
+ * `claude` CLI, so it auto-loads in the CLI and Desktop.
+ *
+ * - **ENOENT-safe**: a missing `claude` binary short-circuits and returns
+ *   `{ claudeFound: false }` so the caller can fall back to a loose skills write.
+ * - **Idempotent**: a non-ENOENT failure (marketplace/plugin already present on a
+ *   re-run or `update`) is tolerated — same-name `marketplace add` replaces the
+ *   prior entry, and a repeated `install` is a no-op — so re-running is safe.
+ */
+export async function registerAndInstallPlugin(exec, dir) {
+    try {
+        await exec('claude', marketplaceAddArgs(dir));
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return { claudeFound: false };
+        // else: tolerate (idempotent re-run) and still attempt the install.
+    }
+    try {
+        await exec('claude', pluginInstallArgs());
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return { claudeFound: false };
+        // else: tolerate (already installed).
+    }
+    return { claudeFound: true };
+}
+/** `--dry-run` lines describing the plugin build + register/install commands. */
+export function pluginDryRunLines(dir, skills) {
+    const lines = [
+        `would write ${path.join(dir, '.claude-plugin', 'marketplace.json')}`,
+        `would write ${path.join(dir, '.claude-plugin', 'plugin.json')}`,
+    ];
+    const skillsRoot = path.join(dir, 'skills');
+    for (const s of skills) {
+        for (const file of s.files) {
+            lines.push(`would write ${path.join(skillsRoot, s.slug, file.path)}`);
+        }
+    }
+    lines.push(`would run: claude ${marketplaceAddArgs(dir).join(' ')}`);
+    lines.push(`would run: claude ${pluginInstallArgs().join(' ')}`);
+    return lines;
+}

package/dist/apps/codex-plugin.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeSkillTree } from '../skills.js';
+import { CONNECTOR_NAME } from './types.js';
+/**
+ * Self-contained local Codex **app-UI plugin** built from the fetched skills and
+ * registered in the user's personal marketplace, so the Reel Edge skills surface
+ * in the Codex / ChatGPT app plugins panel (in addition to the loose
+ * `~/.codex/skills/` CLI skills + the `[mcp_servers.reel-edge]` connector the
+ * codex adapter already writes).
+ *
+ * The plugin is fully self-contained — no remote source. The exact shapes here
+ * were validated against Codex's own plugin validator and installed successfully
+ * in the app:
+ *   - `<homeDir>/plugins/reel-edge/.codex-plugin/plugin.json` (manifest + app-UI `interface`)
+ *   - `<homeDir>/plugins/reel-edge/skills/<slug>/…` (the fetched skill trees)
+ *   - `<homeDir>/.agents/plugins/marketplace.json` (a personal marketplace whose
+ *     `source.path` is the home-relative `./plugins/reel-edge`).
+ *
+ * The marketplace `source` stays the LITERAL home-relative `./plugins/reel-edge`
+ * — Codex resolves it relative to the agents home, so it must NOT be absolutised.
+ */
+/** Plugin `name` (also the marketplace entry name + skills namespace). */
+export const CODEX_PLUGIN_NAME = CONNECTOR_NAME;
+/** Plugin `version` — bump to push skill-content updates to installed users. */
+export const CODEX_PLUGIN_VERSION = '0.1.0';
+/** Absolute plugin directory: `<homeDir>/plugins/reel-edge`. */
+export function codexPluginDir(env) {
+    return path.join(env.homeDir, 'plugins', CODEX_PLUGIN_NAME);
+}
+/** Absolute personal-marketplace path: `<homeDir>/.agents/plugins/marketplace.json`. */
+export function codexMarketplacePath(env) {
+    return path.join(env.homeDir, '.agents', 'plugins', 'marketplace.json');
+}
+/**
+ * `.codex-plugin/plugin.json` body — the exact shape Codex's plugin validator
+ * accepts. `skills: "./skills/"` points at the skill trees; `interface` drives
+ * the app plugins-panel card. Pretty-printed with a trailing newline.
+ */
+export function codexPluginManifest() {
+    const body = {
+        name: CODEX_PLUGIN_NAME,
+        version: CODEX_PLUGIN_VERSION,
+        description: 'Reel Edge read-only data skills: Reel Explorer (Xano database), Inbox Scout (player emails), and HubSpot CRM.',
+        author: { name: 'Reel Edge' },
+        skills: './skills/',
+        interface: {
+            displayName: 'Reel Edge',
+            shortDescription: 'Reel Edge read-only data skills for Codex.',
+            longDescription: 'Adds the Reel Edge domain skills — Reel Explorer (read-only Xano SQL), Inbox Scout (player emails), and HubSpot CRM — used alongside the reel-edge MCP connector.',
+            developerName: 'Reel Edge',
+            category: 'Productivity',
+            capabilities: [],
+            defaultPrompt: 'Query the Reel Edge database.',
+        },
+    };
+    return `${JSON.stringify(body, null, 2)}\n`;
+}
+/**
+ * The reel-edge plugin entry for the personal marketplace. `source.path` is the
+ * literal home-relative `./plugins/reel-edge` (Codex resolves it against the
+ * agents home); `INSTALLED_BY_DEFAULT` makes it show up installed in the panel.
+ */
+export function codexMarketplaceEntry() {
+    return {
+        name: CODEX_PLUGIN_NAME,
+        source: { source: 'local', path: `./plugins/${CODEX_PLUGIN_NAME}` },
+        policy: { installation: 'INSTALLED_BY_DEFAULT', authentication: 'ON_INSTALL' },
+        category: 'Productivity',
+    };
+}
+/** The fresh personal-marketplace root wrapping a single plugin entry. */
+function freshMarketplace(entry) {
+    return {
+        name: 'personal',
+        interface: { displayName: 'Personal' },
+        plugins: [entry],
+    };
+}
+/**
+ * Merge the reel-edge plugin entry into an existing `marketplace.json` body (or
+ * `undefined`/malformed → a fresh personal-marketplace root). Mirrors
+ * `mergeDroidConfig`/`mergeClaudeDesktopConfig`: PRESERVE the user's top-level
+ * keys (incl. their marketplace `name`/`interface`) and any OTHER plugins;
+ * REPLACE an existing reel-edge entry in `plugins[]` (matched by `name`) or
+ * APPEND it. Returns pretty-printed JSON with a trailing newline.
+ */
+export function mergeCodexMarketplace(existing, entry) {
+    let root = null;
+    if (existing && existing.trim() !== '') {
+        try {
+            const parsed = JSON.parse(existing);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                root = parsed;
+            }
+        }
+        catch {
+            root = null;
+        }
+    }
+    if (root === null) {
+        return `${JSON.stringify(freshMarketplace(entry), null, 2)}\n`;
+    }
+    const plugins = Array.isArray(root.plugins) ? [...root.plugins] : [];
+    const idx = plugins.findIndex((p) => p !== null &&
+        typeof p === 'object' &&
+        p.name === entry.name);
+    if (idx >= 0)
+        plugins[idx] = entry;
+    else
+        plugins.push(entry);
+    root.plugins = plugins;
+    // Don't clobber a user's marketplace name/interface; only default them when
+    // absent so the merged file is still a valid personal marketplace.
+    if (root.name === undefined)
+        root.name = 'personal';
+    if (root.interface === undefined)
+        root.interface = { displayName: 'Personal' };
+    return `${JSON.stringify(root, null, 2)}\n`;
+}
+/**
+ * Build the Codex plugin at `dir`:
+ *   dir/.codex-plugin/plugin.json
+ *   dir/skills/<slug>/SKILL.md (+ references/**)
+ * Copies the fetched `SkillFile[]` verbatim (frontmatter carried through) via
+ * {@link writeSkillTree}, so the same path-traversal guards apply. Returns the
+ * written absolute file paths (the manifest first, then the skill files).
+ */
+export function buildCodexPlugin(dir, skills) {
+    const metaDir = path.join(dir, '.codex-plugin');
+    fs.mkdirSync(metaDir, { recursive: true });
+    const pluginPath = path.join(metaDir, 'plugin.json');
+    fs.writeFileSync(pluginPath, codexPluginManifest(), 'utf8');
+    const written = [pluginPath];
+    const skillsRoot = path.join(dir, 'skills');
+    for (const s of skills) {
+        written.push(...writeSkillTree(skillsRoot, s.slug, s.files));
+    }
+    return written;
+}
+/** `--dry-run` lines describing the plugin build + the marketplace merge. */
+export function codexPluginDryRunLines(dir, marketplacePath, skills) {
+    const lines = [`would write ${path.join(dir, '.codex-plugin', 'plugin.json')}`];
+    const skillsRoot = path.join(dir, 'skills');
+    for (const s of skills) {
+        for (const file of s.files) {
+            lines.push(`would write ${path.join(skillsRoot, s.slug, file.path)}`);
+        }
+    }
+    lines.push(`would merge ${marketplacePath} with plugin entry "${CODEX_PLUGIN_NAME}" (INSTALLED_BY_DEFAULT)`);
+    return lines;
+}

package/dist/apps/codex.js

@@ -2,21 +2,39 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { mcpEndpoint } from '../mcp.js';
 import { writeSkillTree } from '../skills.js';
+import { buildCodexPlugin, codexMarketplaceEntry, codexMarketplacePath, codexPluginDir, codexPluginDryRunLines, mergeCodexMarketplace, } from './codex-plugin.js';
 import { APP_LABELS, CONNECTOR_NAME, } from './types.js';
 /**
  * OpenAI Codex CLI adapter. Codex reads `~/.codex/config.toml` and registers
  * MCP servers under `[mcp_servers.<name>]`; a remote Streamable-HTTP server is
  * indicated by a `url` key (no `transport`), and a literal `Authorization`
  * header goes in a static `http_headers` inline table. Codex also has a skills
- * concept — per-skill `SKILL.md` directories under `~/.agents/skills/`.
+ * concept — per-skill `SKILL.md` directories (with optional `references/`,
+ * `scripts/`, `assets/` alongside) under `~/.codex/skills/<slug>/`.
  *
- * Verified against https://developers.openai.com/codex/mcp,
- * https://developers.openai.com/codex/config-reference and
- * https://developers.openai.com/codex/skills (Jun 2026).
+ * Skills path corrected (bug fix): user/global skills load from
+ * `~/.codex/skills`, NOT `~/.agents/skills`. The published docs page
+ * (https://developers.openai.com/codex/skills) still lists `~/.agents/skills`
+ * as the user-level dir, but that is stale/aspirational: an openai/codex
+ * maintainer states skills must live in a `.codex` path for Codex to see them
+ * (github.com/openai/codex/discussions/9682, `.agents/skills` being only a
+ * proposed cross-agent standard), a regression thread confirms `~/.agents/skills`
+ * is no longer discovered in new sessions
+ * (community.openai.com/t/.../1379522), and Codex itself keeps its home under
+ * `~/.codex/` (config.toml, auth.json, vendor_imports/, skills/).
+ *
+ * MCP config verified against https://developers.openai.com/codex/mcp and
+ * https://developers.openai.com/codex/config-reference (Jun 2026).
+ *
+ * On top of the loose CLI skills + the MCP connector, this adapter also builds a
+ * Codex app-UI **plugin** (see `./codex-plugin.ts`) — a self-contained plugin
+ * under `<home>/plugins/reel-edge/` registered in the personal marketplace
+ * (`<home>/.agents/plugins/marketplace.json`) so the skills show in the
+ * Codex/ChatGPT app plugins panel.
  */
-/** Absolute path to the Codex skills tree. */
+/** Absolute path to the Codex skills tree (`~/.codex/skills`). */
 function codexSkillsDir(env) {
-    return path.join(env.homeDir, '.agents', 'skills');
+    return path.join(env.homeDir, '.codex', 'skills');
 }
 /** Absolute path to the Codex config file. */
 function codexConfigPath(env) {
@@ -95,15 +113,29 @@ export function makeCodexAdapter(env) {
         label: APP_LABELS.codex,
         skillsDir,
         writeSkills(skills) {
-            return skills.flatMap((s) => writeSkillTree(skillsDir(), s.slug, s.files));
+            // 1. Loose CLI skills under ~/.codex/skills/<slug>/ (existing behaviour).
+            const cliSkills = skills.flatMap((s) => writeSkillTree(skillsDir(), s.slug, s.files));
+            // 2. The Codex app-UI plugin under <home>/plugins/reel-edge/ so the skills
+            //    also surface in the Codex/ChatGPT app plugins panel.
+            const plugin = buildCodexPlugin(codexPluginDir(env), skills);
+            return [...cliSkills, ...plugin];
         },
         async configureMcp(serverUrl, token) {
+            // 1. MCP connector: ~/.codex/config.toml [mcp_servers.reel-edge] (existing).
             const block = codexConfigBlock(CONNECTOR_NAME, mcpEndpoint(serverUrl), token);
             const cfgPath = codexConfigPath(env);
             const existing = fs.existsSync(cfgPath) ? fs.readFileSync(cfgPath, 'utf8') : '';
             const merged = mergeCodexToml(existing, CONNECTOR_NAME, block);
             fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
             fs.writeFileSync(cfgPath, merged, 'utf8');
+            // 2. Register the app-UI plugin in the personal marketplace so it installs
+            //    in the Codex app plugins panel.
+            const mpPath = codexMarketplacePath(env);
+            const existingMp = fs.existsSync(mpPath) ? fs.readFileSync(mpPath, 'utf8') : undefined;
+            const mergedMp = mergeCodexMarketplace(existingMp, codexMarketplaceEntry());
+            fs.mkdirSync(path.dirname(mpPath), { recursive: true });
+            fs.writeFileSync(mpPath, mergedMp, 'utf8');
+            env.log?.(`Registered Codex plugin (${CONNECTOR_NAME}) — installs in the Codex app plugins panel`);
         },
         dryRunPlan(serverUrl, token, skills) {
             const lines = [];
@@ -116,6 +148,8 @@ export function makeCodexAdapter(env) {
             for (const l of codexConfigBlock(CONNECTOR_NAME, mcpEndpoint(serverUrl), token).trimEnd().split('\n')) {
                 lines.push(`    ${l}`);
             }
+            // The Codex app-UI plugin build + the personal-marketplace registration.
+            lines.push(...codexPluginDryRunLines(codexPluginDir(env), codexMarketplacePath(env), skills));
             return lines;
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reeledge/agent-tools",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "private": false,
   "description": "Reel Edge agent-tools installer CLI — installs/updates the Reel Edge MCP connector + skills for Claude Code / Codex / Droid.",
   "type": "module",