@general-liquidity/gordon-cli 0.75.10 → 0.75.11

package/dist/gordon.js

@@ -1211325,6 +1211325,9 @@ class PluginInstaller {
     const pluginDir = path7.join(this.pluginsDir, listing.id);
     await fs9.mkdir(pluginDir, { recursive: true });
     await fs9.writeFile(path7.join(pluginDir, "manifest.json"), JSON.stringify(listing.manifest, null, 2));
+    if (listing.routingManifest) {
+      await fs9.writeFile(path7.join(pluginDir, "routing.json"), JSON.stringify(listing.routingManifest, null, 2));
+    }
     this.installedPlugins.set(listing.id, installed);
     await this.saveInstalled();
     this.emitProgress({
@@ -1211574,11 +1211577,17 @@ var init_installer = __esm(() => {
   pluginInstaller = new PluginInstaller;
 });
 
-// src/infra/skills/manager.ts
+// src/infra/routing/manager.ts
 import * as fs10 from "fs/promises";
 import * as path8 from "path";
-async function loadSkillManifest(pluginId) {
-  const skillPath = path8.join(pluginInstaller.getPluginsDir(), pluginId, "skill.json");
+async function loadRoutingManifest(pluginId) {
+  const pluginDir = pluginInstaller.getPluginsDir();
+  const routingPath = path8.join(pluginDir, pluginId, "routing.json");
+  try {
+    const content = await fs10.readFile(routingPath, "utf-8");
+    return JSON.parse(content);
+  } catch {}
+  const skillPath = path8.join(pluginDir, pluginId, "skill.json");
   try {
     const content = await fs10.readFile(skillPath, "utf-8");
     return JSON.parse(content);
@@ -1211586,7 +1211595,7 @@ async function loadSkillManifest(pluginId) {
     return null;
   }
 }
-function buildDefaultSkillManifest(pluginId) {
+function buildDefaultRoutingManifest(pluginId) {
   return {
     pluginId,
     defaultAgent: "Gordon",
@@ -1211598,13 +1211607,13 @@ function rebuildRoutingTables() {
   const mcpToolsByServer = getMCPToolsByServer();
   _dynamicToolAgentMap = {};
   _toolsByAgent = {};
-  for (const skill of _resolvedSkills) {
-    if (!skill.enabled)
+  for (const routing of _resolvedRoutings) {
+    if (!routing.enabled)
       continue;
-    const serverToolNames = mcpToolsByServer[skill.pluginId] ?? [];
+    const serverToolNames = mcpToolsByServer[routing.pluginId] ?? [];
     const perToolMap = new Map;
-    if (skill.skillManifest.toolAgentMap) {
-      for (const mapping of skill.skillManifest.toolAgentMap) {
+    if (routing.routingManifest.toolAgentMap) {
+      for (const mapping of routing.routingManifest.toolAgentMap) {
         perToolMap.set(mapping.toolName, mapping.agent);
       }
     }
@@ -1211612,7 +1211621,7 @@ function rebuildRoutingTables() {
     for (const namespacedToolName of serverToolNames) {
       const underscoreIdx = namespacedToolName.indexOf("_");
       const bareToolName = underscoreIdx > 0 ? namespacedToolName.substring(underscoreIdx + 1) : namespacedToolName;
-      const agent = perToolMap.get(bareToolName) ?? skill.skillManifest.defaultAgent;
+      const agent = perToolMap.get(bareToolName) ?? routing.routingManifest.defaultAgent;
       if (agent !== "Gordon") {
         _dynamicToolAgentMap[namespacedToolName] = agent;
       }
@@ -1211622,70 +1211631,70 @@ function rebuildRoutingTables() {
         if (!_toolsByAgent[agent])
           _toolsByAgent[agent] = {};
         _toolsByAgent[agent][namespacedToolName] = tool6;
-        if (skill.skillManifest.alsoOnGordon && agent !== "Gordon") {
+        if (routing.routingManifest.alsoOnGordon && agent !== "Gordon") {
           if (!_toolsByAgent["Gordon"])
             _toolsByAgent["Gordon"] = {};
           _toolsByAgent["Gordon"][namespacedToolName] = tool6;
         }
       }
     }
-    skill.toolCount = toolCount;
+    routing.toolCount = toolCount;
   }
 }
-async function initSkills() {
+async function initRouting() {
   if (_initialized2)
     return;
   await pluginInstaller.initialize();
   const installed = pluginInstaller.getInstalled().filter((p) => p.enabled);
-  _resolvedSkills = [];
+  _resolvedRoutings = [];
   for (const plugin of installed) {
-    const skillManifest = await loadSkillManifest(plugin.id) ?? buildDefaultSkillManifest(plugin.id);
-    _resolvedSkills.push({
+    const routingManifest = await loadRoutingManifest(plugin.id) ?? buildDefaultRoutingManifest(plugin.id);
+    _resolvedRoutings.push({
       pluginId: plugin.id,
-      skillManifest,
+      routingManifest,
       enabled: plugin.enabled,
       toolCount: 0
     });
   }
   rebuildRoutingTables();
   _initialized2 = true;
-  const skillCount = _resolvedSkills.length;
+  const routingCount = _resolvedRoutings.length;
   const routedCount = Object.keys(_dynamicToolAgentMap).length;
-  if (skillCount > 0) {
-    console.log(`[Skills] Loaded ${skillCount} skill(s), ${routedCount} tool(s) routed to sub-agents`);
+  if (routingCount > 0) {
+    console.log(`[Routing] Loaded ${routingCount} config(s), ${routedCount} tool(s) routed to sub-agents`);
   }
 }
 function getDynamicToolAgentMap() {
   return _dynamicToolAgentMap;
 }
-function getSkillToolsForAgent(agentName) {
+function getRoutingToolsForAgent(agentName) {
   return { ..._toolsByAgent[agentName] ?? {} };
 }
-async function reloadSkills() {
+async function reloadRouting() {
   await reloadMCPTools();
   _initialized2 = false;
-  await initSkills();
+  await initRouting();
   resetAgents();
-  console.log("[Skills] Reloaded \u2014 agents will reconstruct on next access");
+  console.log("[Routing] Reloaded \u2014 agents will reconstruct on next access");
 }
-function getResolvedSkills() {
-  return [..._resolvedSkills];
+function getResolvedRoutings() {
+  return [..._resolvedRoutings];
 }
-function isSkillsInitialized() {
+function isRoutingInitialized() {
   return _initialized2;
 }
-async function writeSkillManifest(manifest) {
-  const skillPath = path8.join(pluginInstaller.getPluginsDir(), manifest.pluginId, "skill.json");
-  await fs10.writeFile(skillPath, JSON.stringify(manifest, null, 2));
+async function writeRoutingManifest(manifest) {
+  const routingPath = path8.join(pluginInstaller.getPluginsDir(), manifest.pluginId, "routing.json");
+  await fs10.writeFile(routingPath, JSON.stringify(manifest, null, 2));
 }
-var _resolvedSkills, _dynamicToolAgentMap, _toolsByAgent, _initialized2 = false;
+var _resolvedRoutings, _dynamicToolAgentMap, _toolsByAgent, _initialized2 = false;
 var init_manager4 = __esm(async () => {
   init_installer();
   await __promiseAll([
     init_client14(),
     init_agents()
   ]);
-  _resolvedSkills = [];
+  _resolvedRoutings = [];
   _dynamicToolAgentMap = {};
   _toolsByAgent = {};
 });
@@ -1211909,8 +1211918,8 @@ function enableMCPHotReload(intervalMs = 5000) {
       const fingerprint = installed.map((p) => `${p.id}:${p.enabled ? "1" : "0"}:${p.version ?? "0"}`).sort().join("|");
       if (_lastPluginFingerprint !== null && fingerprint !== _lastPluginFingerprint) {
         console.log("[MCP] Plugin change detected, hot-reloading...");
-        if (isSkillsInitialized()) {
-          await reloadSkills();
+        if (isRoutingInitialized()) {
+          await reloadRouting();
         } else {
           await reloadMCPTools();
         }
@@ -1212054,7 +1212063,7 @@ function getScannerAgent() {
         ...instrumentedMemoryTools,
         ...instrumentedPlaybookTools,
         ...instrumentedRegimeTools,
-        ...getSkillToolsForAgent("Scanner")
+        ...getRoutingToolsForAgent("Scanner")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212117,7 +1212126,7 @@ function getAnalystAgent() {
         detect_market_regime: instrumentedRegimeTools.detect_market_regime,
         get_regime_history: instrumentedRegimeTools.get_regime_history,
         ...instrumentedProtocolTools,
-        ...getSkillToolsForAgent("Analyst")
+        ...getRoutingToolsForAgent("Analyst")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212166,7 +1212175,7 @@ function getPlannerAgent() {
         rebalance_portfolio: instrumentedRuntimeTools.rebalance_portfolio,
         simulate_order_bundle: instrumentedAdvancedTools.simulate_order_bundle,
         generate_circuit_breaker_proof: instrumentedAdvancedTools.generate_circuit_breaker_proof,
-        ...getSkillToolsForAgent("Planner")
+        ...getRoutingToolsForAgent("Planner")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212220,7 +1212229,7 @@ function getExecutorAgent() {
         approve_strategy_trade: instrumentedRuntimeTools.approve_strategy_trade,
         simulate_order_bundle: instrumentedAdvancedTools.simulate_order_bundle,
         verify_circuit_breaker_proof: instrumentedAdvancedTools.verify_circuit_breaker_proof,
-        ...getSkillToolsForAgent("Executor")
+        ...getRoutingToolsForAgent("Executor")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212271,7 +1212280,7 @@ function getMonitorAgent() {
         check_portfolio_health: instrumentedRuntimeTools.check_portfolio_health,
         generate_circuit_breaker_proof: instrumentedAdvancedTools.generate_circuit_breaker_proof,
         query_regime_scoped_memory: instrumentedAdvancedTools.query_regime_scoped_memory,
-        ...getSkillToolsForAgent("Monitor")
+        ...getRoutingToolsForAgent("Monitor")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212300,7 +1212309,7 @@ function getTeacherAgent() {
         ...instrumentedPlaybookTools,
         query_audit_trail: instrumentedAuditTools.query_audit_trail,
         get_decision_path: instrumentedAuditTools.get_decision_path,
-        ...getSkillToolsForAgent("Teacher")
+        ...getRoutingToolsForAgent("Teacher")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212333,7 +1212342,7 @@ function getBacktesterAgent() {
         get_lessons: instrumentedMemoryTools.get_lessons,
         ...instrumentedPlaybookTools,
         ...instrumentedPlaybookBacktestTools,
-        ...getSkillToolsForAgent("Backtester")
+        ...getRoutingToolsForAgent("Backtester")
       },
       memory: createSubAgentMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 32000 })],
@@ -1212367,7 +1212376,7 @@ function getGordonAgent() {
         ...instrumentedSchedulerTools,
         ...instrumentedAutonomousTools,
         ...getMCPTools(),
-        ...getSkillToolsForAgent("Gordon")
+        ...getRoutingToolsForAgent("Gordon")
       },
       memory: createMemory(),
       inputProcessors: [gordonInputGuard, new TokenLimiterProcessor({ limit: 64000 })],
@@ -1212955,11 +1212964,14 @@ When the user asks for analysis, scanning, planning, backtesting, or execution \
 - Raw market data (candles, prices, tickers, orderbook) -> Scanner or Analyst
 - Charts and visualization -> Analyst
 - Whale detection and orderbook analysis -> Analyst
+- Solana: token prices, asset metadata -> Analyst (when solana-agent-kit plugin is installed)
 - Cross-pair correlation, spread analysis, relative strength -> Scanner or Analyst
 - Trade plans with risk sizing -> Planner
 - Strategy generation and backtesting -> Planner and Backtester
 - Order execution, simple swaps/conversions, market orders, limit orders, cancel orders, open orders -> Executor (requires ARMED mode)
+- Solana: Jupiter swaps, SOL/SPL transfers, token deploy, NFT minting -> Executor (when solana-agent-kit plugin is installed)
 - Portfolio, positions, earn, wallet, fund transfers, withdrawals -> Monitor
+- Solana: wallet balances, network TPS -> Monitor (when solana-agent-kit plugin is installed)
 - Educational explanations -> Teacher
 - Position lifecycle tracking (setup \u2192 analysis \u2192 plan \u2192 execute \u2192 monitor \u2192 review) -> tracked automatically across agents
 - Risk pre-checks on all orders -> Planner and Executor (automatic)
@@ -1215517,6 +1215529,8 @@ function getIntegrationCommands(category) {
     "data-provider": ["/scan", "/analyze", "/compare", "/history"],
     analytics: ["/scan", "/analyze", "/signals"],
     execution: ["/trade", "/order", "/position"],
+    exchange: ["/trade", "/order", "/balance"],
+    infrastructure: ["/scan", "/analyze"],
     portfolio: ["/portfolio", "/pnl", "/balance"],
     research: ["/analyze", "/research", "/sentiment"],
     utility: ["/alert", "/notify"]
@@ -1215908,6 +1215922,13 @@ var init_mcp = __esm(() => {
         { id: "dexscreener", summary: "DEX trading data" }
       ]
     },
+    {
+      title: "For Solana",
+      description: "Trade, swap, and manage assets on Solana",
+      plugins: [
+        { id: "solana-agent-kit", summary: "Jupiter swaps, transfers, NFTs, token deploy" }
+      ]
+    },
     {
       title: "For Sentiment",
       description: "Social metrics and market sentiment",
@@ -1215931,7 +1215952,8 @@ var init_mcp = __esm(() => {
     { keywords: ["alert", "notification", "telegram", "notify"], pluginId: "telegram-alerts", reason: "sends alerts to Telegram" },
     { keywords: ["tradingview", "signal", "webhook"], pluginId: "tradingview-signals", reason: "integrates TradingView alerts" },
     { keywords: ["historical", "history", "ohlc", "altcoin", "market cap"], pluginId: "coingecko", reason: "provides historical price data for thousands of coins" },
-    { keywords: ["portfolio", "pnl", "profit", "loss", "tax"], pluginId: "portfolio-tracker", reason: "tracks portfolio and generates tax reports" }
+    { keywords: ["portfolio", "pnl", "profit", "loss", "tax"], pluginId: "portfolio-tracker", reason: "tracks portfolio and generates tax reports" },
+    { keywords: ["solana", "sol", "jupiter", "raydium", "spl", "phantom"], pluginId: "solana-agent-kit", reason: "provides Solana trading, swaps, transfers, and NFT minting via Jupiter" }
   ];
 });
 
@@ -1222762,14 +1222784,14 @@ var SLASH_COMMANDS = [
     target: "handle_mcp_command"
   },
   {
-    name: "skill",
-    aliases: ["skills"],
-    description: "Manage skills (plugins with agent routing)",
-    usage: "/skill <list|search|install|uninstall|route|configure|enable|disable|info|help>",
+    name: "routing",
+    aliases: ["route", "routes"],
+    description: "Manage MCP tool-to-agent routing",
+    usage: "/routing <list|search|install|uninstall|route|configure|enable|disable|info|help>",
     category: "system",
     level: 2,
     action: "tool",
-    target: "handle_skill_command"
+    target: "handle_routing_command"
   },
   {
     name: "workflow",
@@ -1223425,43 +1223447,42 @@ function commandToPrompt(command, args) {
         default:
           return "Show my installed MCP plugins";
       }
-    case "skill":
-    case "skills": {
+    case "routing": {
       if (!args)
-        return "List my installed skills with routing info";
-      const skillParts = args.split(/\s+/);
-      const skillSub = skillParts[0]?.toLowerCase();
-      const skillRest = skillParts.slice(1).join(" ");
-      switch (skillSub) {
+        return "List my installed plugins with routing info";
+      const routingParts = args.split(/\s+/);
+      const routingSub = routingParts[0]?.toLowerCase();
+      const routingRest = routingParts.slice(1).join(" ");
+      switch (routingSub) {
         case "list":
         case "ls":
-          return "List my installed skills with routing info";
+          return "List my installed plugins with routing info";
         case "search":
         case "find":
-          return skillRest ? `Search for skills matching "${skillRest}"` : "Show the skills marketplace";
+          return routingRest ? `Search for plugins matching "${routingRest}"` : "Show the plugin marketplace";
         case "install":
         case "add":
-          return skillRest ? `Install the skill "${skillRest}"` : "Show available skills";
+          return routingRest ? `Install the plugin "${routingRest}"` : "Show available plugins";
         case "uninstall":
         case "remove":
         case "rm":
-          return skillRest ? `Uninstall the skill "${skillRest}"` : "Which skill to uninstall?";
+          return routingRest ? `Uninstall the plugin "${routingRest}"` : "Which plugin to uninstall?";
         case "route":
         case "assign":
-          return `Route skill tools: ${skillRest}`;
+          return `Route plugin tools: ${routingRest}`;
         case "configure":
         case "config":
-          return skillRest ? `Configure credentials for skill "${skillRest}"` : "Which skill to configure?";
+          return routingRest ? `Configure credentials for plugin "${routingRest}"` : "Which plugin to configure?";
         case "enable":
-          return skillRest ? `Enable the skill "${skillRest}"` : "Which skill to enable?";
+          return routingRest ? `Enable the plugin "${routingRest}"` : "Which plugin to enable?";
         case "disable":
-          return skillRest ? `Disable the skill "${skillRest}"` : "Which skill to disable?";
+          return routingRest ? `Disable the plugin "${routingRest}"` : "Which plugin to disable?";
         case "info":
-          return skillRest ? `Show info for skill "${skillRest}"` : "Which skill?";
+          return routingRest ? `Show info for plugin "${routingRest}"` : "Which plugin?";
         case "help":
-          return "Show help for skill management commands";
+          return "Show help for routing management commands";
         default:
-          return "List my installed skills with routing info";
+          return "List my installed plugins with routing info";
       }
     }
     case "workflow":
@@ -1224813,7 +1224834,7 @@ var import_react64 = __toESM(require_react(), 1);
 // package.json
 var package_default2 = {
   name: "@general-liquidity/gordon-cli",
-  version: "0.75.10",
+  version: "0.75.11",
   description: "The Frontier Trading Agent",
   author: "General Liquidity, Inc.",
   license: "MIT",
@@ -1229588,7 +1229609,7 @@ init_theme();
 // src/app/commands/index.ts
 init_mcp();
 
-// src/app/commands/skill.ts
+// src/app/commands/routing.ts
 init_installer();
 init_registry5();
 init_credentials();
@@ -1229606,62 +1229627,62 @@ var VALID_AGENTS = [
 function isValidAgent(name16) {
   return VALID_AGENTS.includes(name16);
 }
-async function skillList() {
-  const skills = getResolvedSkills();
-  if (skills.length === 0) {
+async function routingList() {
+  const routings = getResolvedRoutings();
+  if (routings.length === 0) {
     return {
       success: true,
-      message: `No skills installed.
-Use "/skill search <query>" to find skills or "/skill help" for usage.`
+      message: `No routing configs installed.
+Use "/routing search <query>" to find plugins or "/routing help" for usage.`
     };
   }
-  const lines = [`${skills.length} skill(s) installed:
+  const lines = [`${routings.length} routing config(s) installed:
 `];
-  for (const skill of skills) {
-    const sm = skill.skillManifest;
-    const status = skill.enabled ? "enabled" : "disabled";
-    const routing = sm.toolAgentMap && sm.toolAgentMap.length > 0 ? `${sm.toolAgentMap.length} custom route(s), default -> ${sm.defaultAgent}` : `all -> ${sm.defaultAgent}`;
-    const gordonFlag = sm.alsoOnGordon ? " (+Gordon)" : "";
-    lines.push(`  ${skill.pluginId} [${status}] \u2014 ${skill.toolCount} tool(s) [${routing}${gordonFlag}]`);
+  for (const routing of routings) {
+    const rm3 = routing.routingManifest;
+    const status = routing.enabled ? "enabled" : "disabled";
+    const routes = rm3.toolAgentMap && rm3.toolAgentMap.length > 0 ? `${rm3.toolAgentMap.length} custom route(s), default -> ${rm3.defaultAgent}` : `all -> ${rm3.defaultAgent}`;
+    const gordonFlag = rm3.alsoOnGordon ? " (+Gordon)" : "";
+    lines.push(`  ${routing.pluginId} [${status}] \u2014 ${routing.toolCount} tool(s) [${routes}${gordonFlag}]`);
   }
   return { success: true, message: lines.join(`
-`), data: { skills } };
+`), data: { routings } };
 }
-async function skillInstall(pluginId, defaultAgent = "Scanner") {
+async function routingInstall(pluginId, defaultAgent = "Scanner") {
   const listing = await marketplaceClient.getPlugin(pluginId);
   if (!listing) {
     return {
       success: false,
-      message: `Skill "${pluginId}" not found in marketplace.`
+      message: `Plugin "${pluginId}" not found in marketplace.`
     };
   }
   if (pluginInstaller.isInstalled(pluginId)) {
     return {
       success: false,
-      message: `Skill "${pluginId}" is already installed. Use "/skill route ${pluginId} <agent>" to change routing.`
+      message: `Plugin "${pluginId}" is already installed. Use "/routing route ${pluginId} <agent>" to change routing.`
     };
   }
   await pluginInstaller.install(listing);
-  const skillManifest = {
+  const routingManifest = {
     pluginId,
     defaultAgent,
     alsoOnGordon: false
   };
-  await writeSkillManifest(skillManifest);
-  await reloadSkills();
+  await writeRoutingManifest(routingManifest);
+  await reloadRouting();
   const needsCredentials = listing.manifest.authentication.type !== "none" && !credentialManager.hasRequiredCredentials(listing.manifest);
-  let message4 = `Installed skill "${listing.manifest.name}" -> ${defaultAgent} (${listing.manifest.tools.length} tools)`;
+  let message4 = `Installed plugin "${listing.manifest.name}" -> ${defaultAgent} (${listing.manifest.tools.length} tools)`;
   if (needsCredentials) {
     message4 += `
-Configure credentials: /skill configure ${pluginId}`;
+Configure credentials: /routing configure ${pluginId}`;
   }
   return { success: true, message: message4, data: { pluginId, defaultAgent } };
 }
-async function skillRoute(pluginId, agentName) {
+async function routingRoute(pluginId, agentName) {
   if (!pluginInstaller.isInstalled(pluginId)) {
     return {
       success: false,
-      message: `Skill "${pluginId}" is not installed.`
+      message: `Plugin "${pluginId}" is not installed.`
     };
   }
   if (!isValidAgent(agentName)) {
@@ -1229670,67 +1229691,67 @@ async function skillRoute(pluginId, agentName) {
       message: `Invalid agent "${agentName}". Valid: ${VALID_AGENTS.join(", ")}`
     };
   }
-  const skillManifest = {
+  const routingManifest = {
     pluginId,
     defaultAgent: agentName,
     alsoOnGordon: false
   };
-  await writeSkillManifest(skillManifest);
-  await reloadSkills();
+  await writeRoutingManifest(routingManifest);
+  await reloadRouting();
   return {
     success: true,
-    message: `Skill "${pluginId}" tools now route to ${agentName}.`
+    message: `Plugin "${pluginId}" tools now route to ${agentName}.`
   };
 }
-async function skillUninstall(pluginId) {
+async function routingUninstall(pluginId) {
   const plugin = pluginInstaller.getPlugin(pluginId);
   if (!plugin) {
     return {
       success: false,
-      message: `Skill "${pluginId}" is not installed.`
+      message: `Plugin "${pluginId}" is not installed.`
     };
   }
   const name16 = plugin.manifest.name;
   await pluginInstaller.uninstall(pluginId);
   credentialManager.delete(pluginId);
-  await reloadSkills();
-  return { success: true, message: `Uninstalled skill "${name16}".` };
+  await reloadRouting();
+  return { success: true, message: `Uninstalled plugin "${name16}".` };
 }
-async function skillEnable(pluginId) {
+async function routingEnable(pluginId) {
   if (!pluginInstaller.isInstalled(pluginId)) {
     return {
       success: false,
-      message: `Skill "${pluginId}" is not installed.`
+      message: `Plugin "${pluginId}" is not installed.`
     };
   }
   await pluginInstaller.enable(pluginId);
-  await reloadSkills();
-  return { success: true, message: `Enabled skill "${pluginId}".` };
+  await reloadRouting();
+  return { success: true, message: `Enabled plugin "${pluginId}".` };
 }
-async function skillDisable(pluginId) {
+async function routingDisable(pluginId) {
   if (!pluginInstaller.isInstalled(pluginId)) {
     return {
       success: false,
-      message: `Skill "${pluginId}" is not installed.`
+      message: `Plugin "${pluginId}" is not installed.`
     };
   }
   await pluginInstaller.disable(pluginId);
-  await reloadSkills();
-  return { success: true, message: `Disabled skill "${pluginId}".` };
+  await reloadRouting();
+  return { success: true, message: `Disabled plugin "${pluginId}".` };
 }
-async function handleSkillCommand(args) {
+async function handleRoutingCommand(args) {
   const subcommand = args[0]?.toLowerCase() ?? "list";
   const subArgs = args.slice(1);
   switch (subcommand) {
     case "list":
     case "ls":
-      return skillList();
+      return routingList();
     case "install":
     case "add": {
       if (!subArgs[0]) {
         return {
           success: false,
-          message: "Usage: /skill install <id> [--agent <name>]"
+          message: "Usage: /routing install <id> [--agent <name>]"
         };
       }
       const agentIdx = subArgs.indexOf("--agent");
@@ -1229745,18 +1229766,18 @@ async function handleSkillCommand(args) {
         }
         agent = candidate;
       }
-      return skillInstall(subArgs[0], agent);
+      return routingInstall(subArgs[0], agent);
     }
     case "route":
     case "assign": {
       if (!subArgs[0] || !subArgs[1]) {
         return {
           success: false,
-          message: `Usage: /skill route <id> <agent>
+          message: `Usage: /routing route <id> <agent>
 Agents: ${VALID_AGENTS.join(", ")}`
         };
       }
-      return skillRoute(subArgs[0], subArgs[1]);
+      return routingRoute(subArgs[0], subArgs[1]);
     }
     case "uninstall":
     case "remove":
@@ -1229764,20 +1229785,20 @@ Agents: ${VALID_AGENTS.join(", ")}`
       if (!subArgs[0]) {
         return {
           success: false,
-          message: "Usage: /skill uninstall <id>"
+          message: "Usage: /routing uninstall <id>"
         };
       }
-      return skillUninstall(subArgs[0]);
+      return routingUninstall(subArgs[0]);
     case "enable":
       if (!subArgs[0]) {
-        return { success: false, message: "Usage: /skill enable <id>" };
+        return { success: false, message: "Usage: /routing enable <id>" };
       }
-      return skillEnable(subArgs[0]);
+      return routingEnable(subArgs[0]);
     case "disable":
       if (!subArgs[0]) {
-        return { success: false, message: "Usage: /skill disable <id>" };
+        return { success: false, message: "Usage: /routing disable <id>" };
       }
-      return skillDisable(subArgs[0]);
+      return routingDisable(subArgs[0]);
     case "search":
     case "find": {
       const { mcpSearch: mcpSearch2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
@@ -1229788,7 +1229809,7 @@ Agents: ${VALID_AGENTS.join(", ")}`
       if (!subArgs[0]) {
         return {
           success: false,
-          message: "Usage: /skill configure <id>"
+          message: "Usage: /routing configure <id>"
         };
       }
       const { mcpConfigure: mcpConfigure2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
@@ -1229796,21 +1229817,21 @@ Agents: ${VALID_AGENTS.join(", ")}`
     }
     case "info": {
       if (!subArgs[0]) {
-        return { success: false, message: "Usage: /skill info <id>" };
+        return { success: false, message: "Usage: /routing info <id>" };
       }
       const { mcpInfo: mcpInfo2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
       const infoResult = await mcpInfo2(subArgs[0]);
-      const skills = getResolvedSkills();
-      const skill = skills.find((s2) => s2.pluginId === subArgs[0]);
-      if (skill) {
-        const sm = skill.skillManifest;
-        const routing = sm.toolAgentMap && sm.toolAgentMap.length > 0 ? sm.toolAgentMap.map((m) => `  ${m.toolName} -> ${m.agent}`).join(`
-`) : `  all -> ${sm.defaultAgent}`;
+      const routings = getResolvedRoutings();
+      const routing = routings.find((r) => r.pluginId === subArgs[0]);
+      if (routing) {
+        const rm3 = routing.routingManifest;
+        const routes = rm3.toolAgentMap && rm3.toolAgentMap.length > 0 ? rm3.toolAgentMap.map((m) => `  ${m.toolName} -> ${m.agent}`).join(`
+`) : `  all -> ${rm3.defaultAgent}`;
         infoResult.message += `
 
 Routing:
-${routing}`;
-        if (sm.alsoOnGordon) {
+${routes}`;
+        if (rm3.alsoOnGordon) {
           infoResult.message += `
   (also available on Gordon)`;
         }
@@ -1229820,23 +1229841,23 @@ ${routing}`;
     case "help":
       return {
         success: true,
-        message: `Skill Commands:
-  /skill list                          \u2014 List installed skills with routing
-  /skill search <query>                \u2014 Search marketplace
-  /skill install <id> [--agent <name>] \u2014 Install and route to agent
-  /skill uninstall <id>                \u2014 Remove a skill
-  /skill route <id> <agent>            \u2014 Change agent routing
-  /skill configure <id>                \u2014 Set up credentials
-  /skill enable <id>                   \u2014 Enable a skill
-  /skill disable <id>                  \u2014 Disable a skill
-  /skill info <id>                     \u2014 Show skill details
+        message: `Routing Commands:
+  /routing list                          \u2014 List installed plugins with routing
+  /routing search <query>                \u2014 Search marketplace
+  /routing install <id> [--agent <name>] \u2014 Install and route to agent
+  /routing uninstall <id>                \u2014 Remove a plugin
+  /routing route <id> <agent>            \u2014 Change agent routing
+  /routing configure <id>                \u2014 Set up credentials
+  /routing enable <id>                   \u2014 Enable a plugin
+  /routing disable <id>                  \u2014 Disable a plugin
+  /routing info <id>                     \u2014 Show plugin details
 
 Agents: ${VALID_AGENTS.join(", ")}`
       };
     default:
       return {
         success: false,
-        message: `Unknown subcommand "${subcommand}". Use "/skill help" for usage.`
+        message: `Unknown subcommand "${subcommand}". Use "/routing help" for usage.`
       };
   }
 }
@@ -1232645,7 +1232666,7 @@ function AppContent({ onThemeChange }) {
         if (envStatus.keys.OPENAI_API_KEY) {
           initializeTracing2().catch((err) => console.error("[Tracing] Init failed:", err.message));
         }
-        initMCPTools().then(() => initSkills()).catch((err) => console.error("[Skills] Init failed:", err.message));
+        initMCPTools().then(() => initRouting()).catch((err) => console.error("[Routing] Init failed:", err.message));
         enableMCPHotReload(5000);
       } catch (error48) {
         console.error("Failed to initialize LLM client:", error48);
@@ -1233584,10 +1233605,10 @@ Error: ${result.error || "Unknown error"}`,
             }));
             return;
           }
-          case "handle_skill_command": {
+          case "handle_routing_command": {
             setState((prev) => ({ ...prev, messages: [...prev.messages, userMessage2], isLoading: true }));
-            const skillArgs = args.trim().length > 0 ? args.trim().split(/\s+/) : [];
-            const result = await handleSkillCommand(skillArgs);
+            const routingArgs = args.trim().length > 0 ? args.trim().split(/\s+/) : [];
+            const result = await handleRoutingCommand(routingArgs);
             setState((prev) => ({
               ...prev,
               messages: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@general-liquidity/gordon-cli",
-  "version": "0.75.10",
+  "version": "0.75.11",
   "description": "The Frontier Trading Agent",
   "author": "General Liquidity, Inc.",
   "license": "MIT",