@phnx-labs/agents-cli 1.20.4 → 1.20.5

package/dist/lib/hooks.js

@@ -11,8 +11,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import * as TOML from 'smol-toml';
-import { AGENTS, HOOKS_CAPABLE_AGENTS } from './agents.js';
-import { supports, explainSkip } from './capabilities.js';
+import { AGENTS, agentConfigDirName } from './agents.js';
+import { supports, explainSkip, capableAgents } from './capabilities.js';
 import { setGeminiAutoUpdateDisabled, updateGeminiSettings } from './gemini-settings.js';
 import { getHooksDir as getSystemHooksDir, getUserHooksDir, getUserAgentsDir, getSystemAgentsDir, getProjectAgentsDir, getTrashHooksDir, getEnabledExtraRepos } from './state.js';
 function getCentralHooksDir() { return getUserHooksDir(); }
@@ -117,7 +117,7 @@ function isExecutable(mode) {
 function getHooksDir(agentId) {
     const agent = AGENTS[agentId];
     const home = getEffectiveHome(agentId);
-    return path.join(home, `.${agentId}`, agent.hooksDir);
+    return path.join(home, agentConfigDirName(agentId), agent.hooksDir);
 }
 function getProjectHooksDirs(agentId, cwd) {
     const agent = AGENTS[agentId];
@@ -324,7 +324,7 @@ export function listInstalledHooksWithScope(agentId, cwd = process.cwd(), option
     }
     // User-scoped hooks (version-aware when home is provided)
     const home = options?.home || getEffectiveHome(agentId);
-    const userDir = path.join(home, `.${agentId}`, agent.hooksDir);
+    const userDir = path.join(home, agentConfigDirName(agentId), agent.hooksDir);
     const userHooks = listHookEntriesFromDir(userDir);
     for (const hook of userHooks) {
         addHook(hook, 'user', agentId);
@@ -363,7 +363,7 @@ export async function installHooks(source, agents, options = {}) {
  */
 export function getVersionHooksDir(agent, version) {
     const home = getVersionHomePath(agent, version);
-    return path.join(home, `.${agent}`, AGENTS[agent].hooksDir);
+    return path.join(home, agentConfigDirName(agent), AGENTS[agent].hooksDir);
 }
 /**
  * List hook entries in a specific version home.
@@ -489,7 +489,7 @@ export function removeHookFromVersion(agent, version, hookName) {
  */
 export function iterHooksCapableVersions(filter) {
     const pairs = [];
-    const hookAgents = HOOKS_CAPABLE_AGENTS;
+    const hookAgents = capableAgents('hooks');
     const agents = filter?.agent ? [filter.agent] : hookAgents;
     for (const agent of agents) {
         if (!hookAgents.includes(agent))
@@ -592,7 +592,7 @@ export async function installHooksCentrally(source) {
     return { installed, errors };
 }
 /**
- * List hooks from user (~/.agents/hooks/) and system (~/.agents-system/hooks/) dirs.
+ * List hooks from user (~/.agents/hooks/) and system (~/.agents/.system/hooks/) dirs.
  * User dir takes priority; deduplication preserves first occurrence.
  */
 export function listCentralHooks() {
@@ -609,7 +609,7 @@ export function listCentralHooks() {
     return results;
 }
 /**
- * Parse hook manifests. Reads system hooks from ~/.agents-system/hooks.yaml
+ * Parse hook manifests. Reads system hooks from ~/.agents/.system/hooks.yaml
  * (npm-shipped defaults) and user hooks from the `hooks:` section of
  * ~/.agents/agents.yaml. Merges with user-wins-on-key-collision precedence.
  * A user entry with `enabled: false` disables the system-shipped hook of
@@ -663,7 +663,7 @@ const CODEX_MATCHER_EVENTS = new Set(['PreToolUse', 'PostToolUse', 'SessionStart
  * Register hooks as lifecycle events in an agent's config.
  * Reads hooks.yaml manifest, merges into the agent's config file(s).
  * Only manages hooks whose command paths are under ~/.agents/hooks/ or
- * ~/.agents-system/hooks/. Does not remove user-added hooks.
+ * ~/.agents/.system/hooks/. Does not remove user-added hooks.
  *
  * @param agentsDirOverride - When provided, treats this single dir as the
  *   only managed hook root. Used by tests to inject a temp path. In normal
@@ -702,7 +702,7 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     // Scripts are copied into the version home during sync — prefer that stable
     // local path so registered commands don't break when source dirs change.
     const localHooksDir = !overrideRoots
-        ? path.join(versionHome, `.${agentId}`, AGENTS[agentId].hooksDir)
+        ? path.join(versionHome, agentConfigDirName(agentId), AGENTS[agentId].hooksDir)
         : null;
     const resolveScript = (script) => {
         if (overrideRoots) {
@@ -740,6 +740,9 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     if (agentId === 'grok') {
         return registerHooksForGrok(versionHome, manifest, resolveScript, managedPrefixes);
     }
+    if (agentId === 'kimi') {
+        return registerHooksForKimi(versionHome, manifest, resolveScript, managedPrefixes);
+    }
     return { registered: [], errors: [] };
 }
 /**
@@ -1217,3 +1220,87 @@ function registerHooksForGrok(versionHome, manifest, resolveScript, managedPrefi
     }
     return { registered, errors };
 }
+function registerHooksForKimi(versionHome, manifest, resolveScript, managedPrefixes) {
+    const registered = [];
+    const errors = [];
+    const configPath = path.join(versionHome, '.kimi-code', 'config.toml');
+    // Read existing config.toml
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            errors.push('Failed to parse config.toml');
+            return { registered, errors };
+        }
+    }
+    // Build set of current manifest command paths for GC
+    const currentManifestPaths = new Set();
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
+        if (resolved)
+            currentManifestPaths.add(resolved);
+    }
+    // Remove stale managed hooks from existing hooks array
+    let hooksArray = [];
+    if (Array.isArray(config.hooks)) {
+        hooksArray = config.hooks;
+    }
+    const filteredHooks = hooksArray.filter((h) => {
+        const cmd = typeof h.command === 'string' ? h.command : '';
+        if (!cmd)
+            return true;
+        const isManaged = managedPrefixes.some((p) => cmd.startsWith(p));
+        if (!isManaged)
+            return true;
+        return currentManifestPaths.has(cmd);
+    });
+    // Add/update hooks from manifest
+    for (const [name, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
+        if (!commandPath) {
+            errors.push(`${name}: script not found in user or system hooks dir`);
+            continue;
+        }
+        const timeout = hookDef.timeout ?? 30;
+        for (const event of hookDef.events) {
+            const matcher = hookDef.matcher;
+            // Find existing hook with same event, command, and matcher
+            const existingIdx = filteredHooks.findIndex((h) => {
+                const sameEvent = h.event === event;
+                const sameCmd = h.command === commandPath;
+                const sameMatcher = (h.matcher ?? '') === (matcher ?? '');
+                return sameEvent && sameCmd && sameMatcher;
+            });
+            const hookEntry = {
+                event,
+                command: commandPath,
+                timeout,
+            };
+            if (matcher) {
+                hookEntry.matcher = matcher;
+            }
+            if (existingIdx >= 0) {
+                filteredHooks[existingIdx] = hookEntry;
+            }
+            else {
+                filteredHooks.push(hookEntry);
+            }
+            registered.push(`${name} -> ${event}`);
+        }
+    }
+    config.hooks = filteredHooks;
+    try {
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        fs.writeFileSync(configPath, TOML.stringify(config), 'utf-8');
+    }
+    catch (err) {
+        errors.push(`Failed to write config.toml: ${err.message}`);
+    }
+    return { registered, errors };
+}

package/dist/lib/mcp.js

@@ -13,7 +13,8 @@ import * as yaml from 'yaml';
 import { execFileSync } from 'child_process';
 import { getMcpDir, getUserMcpDir, getProjectAgentsDir, getVersionsDir } from './state.js';
 import { getBinaryPath, getVersionHomePath } from './versions.js';
-import { MCP_CAPABLE_AGENTS, AGENTS } from './agents.js';
+import { AGENTS } from './agents.js';
+import { isCapable } from './capabilities.js';
 import { setGeminiAutoUpdateDisabled, updateGeminiSettings } from './gemini-settings.js';
 /**
  * Parse an MCP server config from a YAML file.
@@ -312,6 +313,31 @@ function installMcpToCursorConfig(server, versionHome) {
 /**
  * Install MCP server to OpenCode config file.
  */
+function installMcpToKimiConfig(server, versionHome) {
+    const configPath = path.join(versionHome, '.kimi-code', 'mcp.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+        config.mcpServers = {};
+    }
+    const mcpServers = config.mcpServers;
+    if (server.config.transport === 'stdio') {
+        mcpServers[server.name] = {
+            command: server.config.command,
+            args: server.config.args || [],
+            env: server.config.env || {},
+        };
+    }
+    else {
+        mcpServers[server.name] = {
+            url: server.config.url,
+        };
+    }
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
 function installMcpToOpenCodeConfig(server, versionHome) {
     const configPath = path.join(versionHome, '.opencode', 'opencode.jsonc');
     let config = {};
@@ -354,7 +380,7 @@ function installMcpToOpenCodeConfig(server, versionHome) {
  * For others: edits config files directly
  */
 export function installMcpServers(agentId, version, versionHome, mcpNames, options = {}) {
-    if (!MCP_CAPABLE_AGENTS.includes(agentId)) {
+    if (!isCapable(agentId, 'mcp')) {
         return { success: true, applied: [], errors: [] };
     }
     const servers = getMcpServersByName(mcpNames, { cwd: options.cwd });
@@ -394,6 +420,10 @@ export function installMcpServers(agentId, version, versionHome, mcpNames, optio
                 // For now the general sync + toml editing via agents mcp works via the path helpers.
                 applied.push(server.name);
             }
+            else if (agentId === 'kimi') {
+                installMcpToKimiConfig(server, versionHome);
+                applied.push(server.name);
+            }
         }
         catch (err) {
             const message = err.message;

package/dist/lib/migrate.d.ts

@@ -4,5 +4,56 @@
  * Called from postinstall and as a command-time fallback from agents view/use/pull.
  * Each migration is guarded by an existence check so re-running is safe.
  */
+/**
+ * Fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
+ * (the new path), so the contents have to be there before they execute.
+ *
+ * Strategy:
+ *   1. If legacy dir doesn't exist or is already a symlink, no-op.
+ *   2. If new path doesn't exist yet, rename in one shot (fast path).
+ *   3. If both exist (mid-migration / re-run on partially-migrated state),
+ *      merge legacy → new with new winning on collision, then drop legacy.
+ *
+ * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
+ * so external tooling that still references ~/.agents-system/ keeps
+ * resolving correctly. The symlink is harmless on its own and can be
+ * removed with `rm ~/.agents-system` once everything has updated.
+ *
+ * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
+ * LEGACY_SYSTEM_DIR" without duplicating data.
+ */
+export declare function foldLegacySystemRepo(): void;
+/**
+ * Rename the legacy `extras-extras/` plugin-marketplace dir to `agents-extras/`
+ * inside every installed agent version-home, and rewrite cross-references in
+ * `known_marketplaces.json` and the agent's `settings.json`.
+ *
+ * A previous dev build of `agents-cli` named the extras-aliased repo's
+ * synthesized marketplace dir `extras-extras` (double "extras" because the alias
+ * itself was `extras`). The new naming convention is `agents-<alias>`, so the
+ * directory should be `agents-extras`. Without this migration the orphan dir
+ * stays on disk and Claude Code loads two parallel marketplaces (the legacy
+ * `extras-extras` entry from `known_marketplaces.json` plus the freshly
+ * synthesized `agents-extras` from the new code path).
+ *
+ * Strategy per `<historyDir>/versions/<agent>/<ver>/home/.<agent>/plugins/`:
+ *   1. `marketplaces/extras-extras/` → `marketplaces/agents-extras/`
+ *      (drops `extras-extras/` outright when `agents-extras/` already exists —
+ *      previous incomplete migration ran)
+ *   2. Inside the renamed dir's `.claude-plugin/marketplace.json`, set
+ *      `"name": "agents-extras"`.
+ *   3. In `<configDir>/plugins/known_marketplaces.json`, rename the
+ *      `extras-extras` key to `agents-extras` and rewrite `source.path` /
+ *      `installLocation`.
+ *   4. In `<configDir>/settings.json`'s `enabledPlugins`, rename every
+ *      `<plugin>@extras-extras` key to `<plugin>@agents-extras` (preserving
+ *      its boolean value, skipping if the new key already exists).
+ *
+ * Idempotent: re-running converges without further writes once everything is on
+ * the new name.
+ */
+export declare function migrateExtrasExtrasToAgentsExtras(historyDir?: string): void;
 /** Run all idempotent migrations. Safe to call multiple times. */
 export declare function runMigration(): Promise<void>;

package/dist/lib/migrate.js

@@ -9,10 +9,74 @@ import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
 const HOME = process.env.HOME ?? os.homedir();
-const SYSTEM_DIR = path.join(HOME, '.agents-system');
 const USER_DIR = path.join(HOME, '.agents');
+/** Canonical system-repo location (post-fold). */
+const SYSTEM_DIR = path.join(USER_DIR, '.system');
+/** Legacy system-repo location — folded into SYSTEM_DIR by foldLegacySystemRepo(). */
+const LEGACY_SYSTEM_DIR = path.join(HOME, '.agents-system');
 const HISTORY_DIR = path.join(USER_DIR, '.history');
 const CACHE_DIR = path.join(USER_DIR, '.cache');
+/**
+ * Fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
+ * (the new path), so the contents have to be there before they execute.
+ *
+ * Strategy:
+ *   1. If legacy dir doesn't exist or is already a symlink, no-op.
+ *   2. If new path doesn't exist yet, rename in one shot (fast path).
+ *   3. If both exist (mid-migration / re-run on partially-migrated state),
+ *      merge legacy → new with new winning on collision, then drop legacy.
+ *
+ * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
+ * so external tooling that still references ~/.agents-system/ keeps
+ * resolving correctly. The symlink is harmless on its own and can be
+ * removed with `rm ~/.agents-system` once everything has updated.
+ *
+ * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
+ * LEGACY_SYSTEM_DIR" without duplicating data.
+ */
+export function foldLegacySystemRepo() {
+    let legacyStat = null;
+    try {
+        legacyStat = fs.lstatSync(LEGACY_SYSTEM_DIR);
+    }
+    catch { /* missing */ }
+    if (!legacyStat)
+        return;
+    if (legacyStat.isSymbolicLink())
+        return;
+    if (!legacyStat.isDirectory())
+        return;
+    try {
+        fs.mkdirSync(USER_DIR, { recursive: true, mode: 0o700 });
+    }
+    catch { /* best-effort */ }
+    if (!fs.existsSync(SYSTEM_DIR)) {
+        try {
+            fs.renameSync(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
+            try {
+                fs.symlinkSync(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
+            }
+            catch { /* best-effort */ }
+            console.error('Folded ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
+            return;
+        }
+        catch {
+            // Cross-device rename or perm issue — fall through to copy + remove.
+        }
+    }
+    try {
+        copyDirSkipExisting(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
+        fs.rmSync(LEGACY_SYSTEM_DIR, { recursive: true, force: true });
+        try {
+            fs.symlinkSync(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
+        }
+        catch { /* best-effort */ }
+        console.error('Merged ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
+    }
+    catch { /* best-effort */ }
+}
 /**
  * Move ~/.agents-system/agents.yaml -> ~/.agents/agents.yaml.
  * No-op if user file already exists or system file absent.
@@ -1461,8 +1525,166 @@ function migrateVersionResourcesToPatterns() {
         console.error('Migrated agents.yaml versions: entries to pattern format');
     }
 }
+/**
+ * Rename the legacy `extras-extras/` plugin-marketplace dir to `agents-extras/`
+ * inside every installed agent version-home, and rewrite cross-references in
+ * `known_marketplaces.json` and the agent's `settings.json`.
+ *
+ * A previous dev build of `agents-cli` named the extras-aliased repo's
+ * synthesized marketplace dir `extras-extras` (double "extras" because the alias
+ * itself was `extras`). The new naming convention is `agents-<alias>`, so the
+ * directory should be `agents-extras`. Without this migration the orphan dir
+ * stays on disk and Claude Code loads two parallel marketplaces (the legacy
+ * `extras-extras` entry from `known_marketplaces.json` plus the freshly
+ * synthesized `agents-extras` from the new code path).
+ *
+ * Strategy per `<historyDir>/versions/<agent>/<ver>/home/.<agent>/plugins/`:
+ *   1. `marketplaces/extras-extras/` → `marketplaces/agents-extras/`
+ *      (drops `extras-extras/` outright when `agents-extras/` already exists —
+ *      previous incomplete migration ran)
+ *   2. Inside the renamed dir's `.claude-plugin/marketplace.json`, set
+ *      `"name": "agents-extras"`.
+ *   3. In `<configDir>/plugins/known_marketplaces.json`, rename the
+ *      `extras-extras` key to `agents-extras` and rewrite `source.path` /
+ *      `installLocation`.
+ *   4. In `<configDir>/settings.json`'s `enabledPlugins`, rename every
+ *      `<plugin>@extras-extras` key to `<plugin>@agents-extras` (preserving
+ *      its boolean value, skipping if the new key already exists).
+ *
+ * Idempotent: re-running converges without further writes once everything is on
+ * the new name.
+ */
+export function migrateExtrasExtrasToAgentsExtras(historyDir = HISTORY_DIR) {
+    const versionsRoot = path.join(historyDir, 'versions');
+    if (!fs.existsSync(versionsRoot))
+        return;
+    const OLD = 'extras-extras';
+    const NEW = 'agents-extras';
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(versionsRoot, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    let renamedDirs = 0;
+    let rewroteKnown = 0;
+    let rewroteSettings = 0;
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const agentId = agentEntry.name;
+        const agentVersionsDir = path.join(versionsRoot, agentId);
+        let verEntries;
+        try {
+            verEntries = fs.readdirSync(agentVersionsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const ver of verEntries) {
+            if (!ver.isDirectory())
+                continue;
+            const configDir = path.join(agentVersionsDir, ver.name, 'home', `.${agentId}`);
+            const pluginsDir = path.join(configDir, 'plugins');
+            if (!fs.existsSync(pluginsDir))
+                continue;
+            const marketplacesDir = path.join(pluginsDir, 'marketplaces');
+            const oldDir = path.join(marketplacesDir, OLD);
+            const newDir = path.join(marketplacesDir, NEW);
+            const oldExists = fs.existsSync(oldDir);
+            const newExists = fs.existsSync(newDir);
+            if (oldExists && !newExists) {
+                try {
+                    fs.renameSync(oldDir, newDir);
+                    renamedDirs++;
+                }
+                catch { /* best-effort, leave orphan */ }
+            }
+            else if (oldExists && newExists) {
+                // Previous incomplete migration — drop the stale old dir.
+                try {
+                    fs.rmSync(oldDir, { recursive: true, force: true });
+                }
+                catch { /* best-effort */ }
+            }
+            // Rewrite marketplace.json name field inside the (now) agents-extras dir.
+            const marketplaceJson = path.join(newDir, '.claude-plugin', 'marketplace.json');
+            if (fs.existsSync(marketplaceJson)) {
+                try {
+                    const raw = fs.readFileSync(marketplaceJson, 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed?.name === OLD) {
+                        parsed.name = NEW;
+                        fs.writeFileSync(marketplaceJson, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+            // Rewrite known_marketplaces.json key + path fields.
+            const knownFile = path.join(pluginsDir, 'known_marketplaces.json');
+            if (fs.existsSync(knownFile)) {
+                try {
+                    const raw = fs.readFileSync(knownFile, 'utf-8');
+                    const known = JSON.parse(raw);
+                    if (known && typeof known === 'object' && OLD in known) {
+                        const entry = known[OLD];
+                        if (!(NEW in known)) {
+                            if (entry?.source?.path)
+                                entry.source.path = entry.source.path.split(OLD).join(NEW);
+                            if (entry?.installLocation)
+                                entry.installLocation = entry.installLocation.split(OLD).join(NEW);
+                            known[NEW] = entry;
+                        }
+                        delete known[OLD];
+                        fs.writeFileSync(knownFile, JSON.stringify(known, null, 2) + '\n', 'utf-8');
+                        rewroteKnown++;
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+            // Rewrite settings.json enabledPlugins keys.
+            const settingsFile = path.join(configDir, 'settings.json');
+            if (fs.existsSync(settingsFile)) {
+                try {
+                    const raw = fs.readFileSync(settingsFile, 'utf-8');
+                    const settings = JSON.parse(raw);
+                    const enabled = settings?.enabledPlugins;
+                    if (enabled && typeof enabled === 'object') {
+                        const suffix = `@${OLD}`;
+                        const newSuffix = `@${NEW}`;
+                        let changed = false;
+                        for (const key of Object.keys(enabled)) {
+                            if (!key.endsWith(suffix))
+                                continue;
+                            const renamed = key.slice(0, -suffix.length) + newSuffix;
+                            if (renamed in enabled) {
+                                delete enabled[key];
+                            }
+                            else {
+                                enabled[renamed] = enabled[key];
+                                delete enabled[key];
+                            }
+                            changed = true;
+                        }
+                        if (changed) {
+                            fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+                            rewroteSettings++;
+                        }
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    if (renamedDirs > 0 || rewroteKnown > 0 || rewroteSettings > 0) {
+        console.error(`Renamed extras-extras → agents-extras (dirs: ${renamedDirs}, known_marketplaces: ${rewroteKnown}, settings: ${rewroteSettings})`);
+    }
+}
 /** Run all idempotent migrations. Safe to call multiple times. */
 export async function runMigration() {
+    // MUST run first: every other migrator reads SYSTEM_DIR (the new path).
+    foldLegacySystemRepo();
     migrateAgentsYaml();
     deleteSystemPromptsJson();
     migrateSystemConfigJson();
@@ -1503,6 +1725,10 @@ export async function runMigration() {
     await migrateSystemCloudToCache();
     dropDeadSystemArtifacts();
     warnSystemOrphans();
+    // Rename the legacy extras-extras marketplace dir to agents-extras across every
+    // installed version-home. Runs after migrateRuntimeToHistory so the version
+    // homes are at their canonical HISTORY_DIR location.
+    migrateExtrasExtrasToAgentsExtras();
     // Symlink repair runs LAST so it can find the post-move version homes.
     repairAgentConfigSymlinks();
 }

package/dist/lib/models.js

@@ -78,27 +78,72 @@ export function locateModelSource(agent, version) {
         return null;
     }
     if (agent === 'codex') {
+        // Codex's vendored binary has moved across releases:
+        //   <=0.98:     @openai/codex/vendor/<triple>/codex/codex
+        //   0.99..0.13: @openai/codex-<plat>-<arch>/vendor/<triple>/codex/codex
+        //   0.134+:     @openai/codex-<plat>-<arch>/vendor/<triple>/bin/codex
+        // We probe all known shapes; first hit wins.
+        const triples = ['aarch64-apple-darwin', 'x86_64-apple-darwin', 'x86_64-unknown-linux-musl', 'aarch64-unknown-linux-musl', 'x86_64-pc-windows-msvc', 'aarch64-pc-windows-msvc'];
         const triple = currentTargetTriple();
-        if (triple) {
-            const platformPkg = path.join(versionDir, 'node_modules', '@openai', `codex-${triple.includes('apple') ? 'darwin' : triple.includes('linux') ? 'linux' : 'win32'}-${triple.includes('aarch64') ? 'arm64' : 'x64'}`, 'vendor', triple, 'codex', 'codex');
-            if (fs.existsSync(platformPkg))
-                return { path: platformPkg, kind: 'binary' };
-        }
-        // 0.98 layout: binary inside @openai/codex itself
-        const triples = ['aarch64-apple-darwin', 'x86_64-apple-darwin', 'x86_64-unknown-linux-musl', 'aarch64-unknown-linux-musl'];
-        for (const t of triples) {
-            const p = path.join(versionDir, 'node_modules', '@openai', 'codex', 'vendor', t, 'codex', 'codex');
-            if (fs.existsSync(p))
-                return { path: p, kind: 'binary' };
+        const orderedTriples = triple ? [triple, ...triples.filter((t) => t !== triple)] : triples;
+        const platformPkgFor = (t) => `codex-${t.includes('apple') ? 'darwin' : t.includes('linux') ? 'linux' : 'win32'}-${t.includes('aarch64') ? 'arm64' : 'x64'}`;
+        for (const t of orderedTriples) {
+            const candidates = [
+                path.join(versionDir, 'node_modules', '@openai', platformPkgFor(t), 'vendor', t, 'bin', 'codex'),
+                path.join(versionDir, 'node_modules', '@openai', platformPkgFor(t), 'vendor', t, 'codex', 'codex'),
+                path.join(versionDir, 'node_modules', '@openai', 'codex', 'vendor', t, 'bin', 'codex'),
+                path.join(versionDir, 'node_modules', '@openai', 'codex', 'vendor', t, 'codex', 'codex'),
+            ];
+            for (const p of candidates) {
+                if (fs.existsSync(p))
+                    return { path: p, kind: 'binary' };
+            }
         }
         return null;
     }
     if (agent === 'gemini') {
-        // Gemini ships a clean ES module with all constants and aliases -- no need
-        // to parse the minified CLI bundle.
+        // <=0.41 shipped a clean ES module at @google/gemini-cli-core/dist/src/config/models.js.
+        // 0.42+ inlines the same constants into a minified chunk under @google/gemini-cli/bundle/.
         const modelsJs = path.join(versionDir, 'node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'config', 'models.js');
         if (fs.existsSync(modelsJs))
             return { path: modelsJs, kind: 'js' };
+        const bundleDir = path.join(versionDir, 'node_modules', '@google', 'gemini-cli', 'bundle');
+        if (fs.existsSync(bundleDir)) {
+            try {
+                const entries = fs.readdirSync(bundleDir);
+                // The model constants live in a single chunk; pick the first .js file
+                // whose contents contain VALID_GEMINI_MODELS. Skip subdirectories.
+                for (const name of entries) {
+                    if (!name.endsWith('.js'))
+                        continue;
+                    const full = path.join(bundleDir, name);
+                    let stat;
+                    try {
+                        stat = fs.statSync(full);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!stat.isFile())
+                        continue;
+                    // Most chunks just re-export the constants; only the defining chunk
+                    // actually has `var VALID_GEMINI_MODELS = ... new Set(`. Match that
+                    // shape so we pick the chunk that the extractor can parse.
+                    let body;
+                    try {
+                        body = fs.readFileSync(full, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (/var\s+VALID_GEMINI_MODELS\s*=[^\n]*new\s+Set/.test(body) &&
+                        /var\s+DEFAULT_GEMINI_MODEL\s*=/.test(body)) {
+                        return { path: full, kind: 'js' };
+                    }
+                }
+            }
+            catch { /* unreadable bundle dir */ }
+        }
         return null;
     }
     if (agent === 'opencode') {
@@ -296,7 +341,9 @@ function extractCodexCatalog(text) {
  * would pollute the runtime and ES-module interop is awkward from a CJS build).
  */
 function extractGeminiCatalog(text) {
-    const constRe = /export\s+const\s+([A-Z0-9_]+)\s*=\s*'([^']+)'/g;
+    // Old (<=0.41) layout used `export const FOO = 'bar';` in models.js.
+    // New (0.42+) bundle inlines the same constants as `var FOO = "bar";`.
+    const constRe = /(?:export\s+const|var)\s+([A-Z0-9_]+)\s*=\s*['"]([^'"]+)['"]/g;
     const constants = new Map();
     let m;
     while ((m = constRe.exec(text)) !== null) {
@@ -305,7 +352,7 @@ function extractGeminiCatalog(text) {
     // The set of ids the CLI accepts as "valid model names". Names (not values)
     // are listed inside `new Set([...])`, so we expand them via the constants map.
     const validIds = new Set();
-    const setBlock = text.match(/VALID_GEMINI_MODELS\s*=\s*new\s+Set\(\[([\s\S]*?)\]\)/);
+    const setBlock = text.match(/VALID_GEMINI_MODELS\s*=\s*(?:\/\*[^*]*\*\/\s*)?new\s+Set\(\[([\s\S]*?)\]\)/);
     if (setBlock) {
         const nameRe = /([A-Z0-9_]+)/g;
         let nm;