farming-code 2.2.28 → 2.2.29

package/backend/runtime-executable-invocation.js

@@ -0,0 +1,20 @@
+function runtimeExecutableInvocation(
+  executablePath,
+  args = [],
+  env = process.env,
+  platform = process.platform,
+) {
+  if (
+    platform === 'linux'
+    && env.FARMING_NODE_LD
+    && env.FARMING_NODE_LIBRARY_PATH
+  ) {
+    return {
+      command: env.FARMING_NODE_LD,
+      args: ['--library-path', env.FARMING_NODE_LIBRARY_PATH, executablePath, ...args],
+    };
+  }
+  return { command: executablePath, args };
+}
+
+module.exports = { runtimeExecutableInvocation };

package/backend/server-process-identity.js

@@ -0,0 +1,47 @@
+const { execFileSync } = require('child_process');
+
+const SERVER_PROCESS_IDENTITY_FORMAT = 'ps-lstart-c-utc-v1';
+
+function readServerProcessIdentity(pid) {
+  const processId = Number(pid);
+  if (!Number.isSafeInteger(processId) || processId <= 0 || process.platform === 'win32') return null;
+  let stdout;
+  try {
+    stdout = execFileSync(
+      '/bin/ps',
+      ['-p', String(processId), '-o', 'pid=', '-o', 'pgid=', '-o', 'lstart='],
+      {
+        encoding: 'utf8',
+        timeout: 1_000,
+        maxBuffer: 16_384,
+        env: { ...process.env, LANG: 'C', LC_ALL: 'C', TZ: 'UTC' },
+      },
+    );
+  } catch (error) {
+    if (error?.status === 1 || error?.code === 'ESRCH') return null;
+    throw error;
+  }
+  const match = String(stdout || '').trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+  if (!match || Number(match[1]) !== processId) return null;
+  return {
+    pid: processId,
+    processGroupId: Number(match[2]),
+    startedAt: match[3].trim(),
+    format: SERVER_PROCESS_IDENTITY_FORMAT,
+  };
+}
+
+function matchingProcessIdentity(expected, current) {
+  return Boolean(
+    current
+    && current.pid === Number(expected?.pid)
+    && current.processGroupId === Number(expected?.processGroupId)
+    && current.startedAt === String(expected?.startedAt || '')
+  );
+}
+
+module.exports = {
+  SERVER_PROCESS_IDENTITY_FORMAT,
+  matchingProcessIdentity,
+  readServerProcessIdentity,
+};

package/backend/server.js

@@ -51,9 +51,8 @@ const { CodexContextWindowReader } = require('./codex-context-window');
 const { DEFAULT_MAX_TURNS: DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS, readCodexTranscript } = require('./codex-transcript');
 const { AsyncCache } = require('./async-cache');
 const { getMainAgentSkillsCatalog } = require('./main-agent-skills');
-const { discoverSlashCommands } = require('./slash-command-discovery');
+const { discoverAgentExtensions, discoverSlashCommands } = require('./slash-command-discovery');
 const { FarmingUpdateService } = require('./update-service');
-const { isRestartBlockingAgent } = require('./agent-activity');
 const { inputPartsFromMessage } = require('./input-parts');
 const { cleanupTerminalRuntime } = require('./terminal-runtime-cleanup');
 const { QrShareTicketStore, SHARE_TICKET_TTL_MS } = require('./qr-share-tickets');
@@ -65,11 +64,13 @@ const { ReviewSessionStore } = require('./review-session-store');
 const { ReviewSessionService } = require('./review-session-service');
 const { createReviewSessionRouter } = require('./review-session-router');
 const {
+  applyIndexHtmlAppearance,
   normalizeBasePath,
   routePath,
   rewriteIndexHtmlForBasePath,
   appendIndexHtmlAssetToken,
 } = require('./index-html');
+const { decodeAcpTranscriptMedia } = require('./acp-transcript');
 const {
   coalesceSessionStream,
   deliverSessionStreamToClients,
@@ -136,8 +137,12 @@ const workspaceRootRegistry = new WorkspaceRootRegistry(agentManager);
 const browserResourceManager = new BrowserResourceManager({
   configDir: configManager.farmingDir,
   isEnabled: () => configManager.getSettings().browserExtensionEnabled === true,
+  getBrowserSettings: () => configManager.getSettings(),
+});
+const browserRuntimeRecoveryPromise = browserResourceManager.init().catch(error => {
+  console.warn('Failed to recover Browser runtimes:', error?.message || error);
+  return null;
 });
-browserResourceManager.init();
 const updateService = new FarmingUpdateService({
   rootDir: path.join(__dirname, '..'),
   configDir: configManager.farmingDir,
@@ -255,6 +260,22 @@ function getAvailableAgentsForRequest() {
         supported: true,
         interactive: true,
       },
+      {
+        name: 'opencode',
+        command: 'opencode',
+        description: 'OpenCode - AI coding assistant',
+        category: 'coding',
+        supported: true,
+        interactive: true,
+      },
+      {
+        name: 'qoder',
+        command: 'qodercli',
+        description: 'Qoder - AI coding assistant',
+        category: 'coding',
+        supported: true,
+        interactive: true,
+      },
       {
         name: 'bash',
         command: 'bash',
@@ -574,7 +595,10 @@ app.get([
     }
     res.setHeader('Content-Type', 'text/html; charset=utf-8');
     res.setHeader('Cache-Control', 'no-cache');
-    const rewrittenHtml = rewriteIndexHtmlForBasePath(html, BASE_PATH);
+    const rewrittenHtml = applyIndexHtmlAppearance(
+      rewriteIndexHtmlForBasePath(html, BASE_PATH),
+      configManager.getSettings().appearance
+    );
     const requestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
     const requestToken = requestUrl.searchParams.has('token') ? tokenAuth.extractToken(req) : '';
     const htmlWithAssetToken = authEnabled && requestToken && tokenAuth.verify(requestToken)
@@ -613,6 +637,40 @@ app.get(routePath(BASE_PATH, '/api/skills'), (_req, res) => {
   res.json({ skills: getMainAgentSkillsCatalog() });
 });
 
+app.get(routePath(BASE_PATH, '/api/agent-extensions'), (_req, res) => {
+  const agents = getAvailableAgentsForRequest()
+    .filter(agent => agent.category === 'coding')
+    .map(agent => {
+      const provider = String(agent.name || agent.command || '').trim().toLowerCase();
+      const configuredHomes = configManager.getAgentHomes(provider);
+      const homes = configuredHomes.length > 0
+        ? configuredHomes
+        : [{ id: 'default', path: '' }];
+      return {
+        id: provider,
+        name: agent.name,
+        description: agent.description || '',
+        discoverySupported: provider === 'codex' || provider === 'claude',
+        homes: homes.map(home => ({
+          id: home.id,
+          extensions: discoverAgentExtensions({
+            provider,
+            providerHomePath: home.path,
+          }).map(extension => ({
+            id: extension.command,
+            command: extension.command,
+            name: extension.label,
+            description: extension.description,
+            kind: extension.source === 'custom' ? 'command' : extension.source || 'command',
+            scope: extension.scope || '',
+          })),
+        })),
+      };
+    });
+  res.setHeader('Cache-Control', 'no-store');
+  res.json({ agents });
+});
+
 app.get(routePath(BASE_PATH, '/api/slash-commands'), (req, res) => {
   const provider = typeof req.query.provider === 'string' ? req.query.provider : '';
   const workspace = typeof req.query.workspace === 'string' ? req.query.workspace : '';
@@ -815,26 +873,10 @@ app.post(routePath(BASE_PATH, '/api/codex/context-windows'), express.json(), asy
   }
 });
 
-function blockingUpdateAgents() {
-  return agentManager.getState().agents
-    .filter(isRestartBlockingAgent)
-    .map(agent => ({
-      id: agent.id,
-      command: agent.command,
-      task: agent.task || agent.customTitle || agent.sessionTitle || '',
-      cwd: agent.cwd,
-    }));
-}
-
 app.get(routePath(BASE_PATH, '/api/update'), async (req, res) => {
   try {
     const update = await updateService.check({ force: req.query.force === '1' });
-    res.json({
-      update: {
-        ...update,
-        blockingAgents: blockingUpdateAgents(),
-      },
-    });
+    res.json({ update });
   } catch (error) {
     res.status(502).json({ error: error.message || 'Failed to check for updates' });
   }
@@ -845,31 +887,16 @@ app.post(routePath(BASE_PATH, '/api/update/install'), express.json(), async (req
     const state = await updateService.startInstall({
       assetName: req.body && typeof req.body.assetName === 'string' ? req.body.assetName : '',
     });
-    res.status(202).json({
-      update: {
-        state,
-        blockingAgents: blockingUpdateAgents(),
-      },
-    });
+    res.status(202).json({ update: { state } });
   } catch (error) {
     res.status(500).json({ error: error.message || 'Failed to start update' });
   }
 });
 
 app.post(routePath(BASE_PATH, '/api/update/restart'), express.json(), async (req, res) => {
-  const blockers = blockingUpdateAgents();
-  const force = req.body && req.body.force === true;
-  if (blockers.length > 0 && !force) {
-    res.status(409).json({
-      error: 'Cannot restart for update while non-recoverable project agents are running',
-      blockingAgents: blockers,
-    });
-    return;
-  }
-
   try {
     const state = await updateService.applyPreparedUpdate();
-    res.status(202).json({ update: { state, blockingAgents: blockers } });
+    res.status(202).json({ update: { state } });
   } catch (error) {
     res.status(500).json({ error: error.message || 'Failed to restart for update' });
   }
@@ -1152,8 +1179,17 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-transcript'), async (req,
       ? Math.min(MAX_CODEX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
       : DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS;
     const requestedRevision = Number.parseInt(String(req.query.sinceRevision || ''), 10);
+    const externalMedia = req.query.media === 'external-v1';
     res.json({ transcript: agentManager.getAcpTranscript(req.params.agentId, {
       maxTurns,
+      ...(externalMedia
+        ? {
+            mediaPathPrefix: routePath(
+              BASE_PATH,
+              `/api/agents/${encodeURIComponent(req.params.agentId)}/acp-media`
+            ),
+          }
+        : {}),
       ...(Number.isFinite(requestedRevision) && requestedRevision >= 0
         ? { sinceRevision: requestedRevision }
         : {}),
@@ -1164,6 +1200,32 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-transcript'), async (req,
   }
 });
 
+app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-media/:entryId/:mediaId'), (req, res) => {
+  try {
+    const media = agentManager.getAcpTranscriptMedia(
+      req.params.agentId,
+      req.params.entryId,
+      req.params.mediaId
+    );
+    const decoded = decodeAcpTranscriptMedia(media);
+    if (!decoded) {
+      res.status(415).json({ error: 'unsupported ACP transcript media' });
+      return;
+    }
+    res.setHeader('Cache-Control', 'private, max-age=31536000, immutable');
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.type(decoded.mimeType).send(decoded.content);
+  } catch (error) {
+    const message = error && error.message ? error.message : 'Failed to read ACP transcript media';
+    const status = message === 'Agent not found'
+      || message === 'ACP transcript entry not found'
+      || message === 'ACP transcript media not found'
+      ? 404
+      : 409;
+    res.status(status).json({ error: message });
+  }
+});
+
 app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-tool-details/:toolCallId'), async (req, res) => {
   try {
     res.json(agentManager.getAcpToolDetail(req.params.agentId, req.params.toolCallId));
@@ -2209,19 +2271,44 @@ app.post(routePath(BASE_PATH, '/api/settings'), express.json(), async (req, res)
   delete settingsPatch.mainPageSessionKeys;
   delete settingsPatch.projectWorkspaces;
   delete settingsPatch.pinnedProjectWorkspaces;
+  const browserConfigurationKeys = [
+    'browserSource',
+    'browserExecutablePath',
+    'browserExternalCdpUrl',
+  ];
   const changesBrowserExtension = Object.prototype.hasOwnProperty.call(settingsPatch, 'browserExtensionEnabled');
+  const changesBrowserConfiguration = browserConfigurationKeys.some(key =>
+    Object.prototype.hasOwnProperty.call(settingsPatch, key)
+  );
+  const currentSettings = configManager.getSettings();
   const browserExtensionEnabled = settingsPatch.browserExtensionEnabled === true;
-  if (changesBrowserExtension && browserExtensionEnabled && !browserResourceManager.capability().browser) {
-    res.status(400).json({
-      error: 'Install a Chromium-based browser to use the system Browser in Farming',
-      code: 'BROWSER_EXECUTABLE_NOT_FOUND',
+  const desiredBrowserEnabled = changesBrowserExtension
+    ? browserExtensionEnabled
+    : currentSettings.browserExtensionEnabled === true;
+  if ((changesBrowserExtension && browserExtensionEnabled) || changesBrowserConfiguration) {
+    const desiredSelection = browserResourceManager.browserSelection({
+      ...currentSettings,
+      ...settingsPatch,
     });
-    return;
+    const probe = await browserResourceManager.probeCapability(desiredSelection);
+    if (
+      (changesBrowserConfiguration || desiredBrowserEnabled)
+      && (!probe.runtimeCapability || probe.runtimeCapability.error)
+    ) {
+      res.status(400).json({
+        error: probe.runtimeCapability?.error
+          || 'Install a Chromium-based browser or configure a loopback external CDP endpoint',
+        code: 'BROWSER_EXECUTABLE_NOT_FOUND',
+      });
+      return;
+    }
   }
   if (
-    changesBrowserExtension
-    && !browserExtensionEnabled
-    && configManager.getSettings().browserExtensionEnabled === true
+    currentSettings.browserExtensionEnabled === true
+    && (
+      (changesBrowserExtension && !browserExtensionEnabled)
+      || changesBrowserConfiguration
+    )
   ) {
     try {
       await browserResourceManager.stopAll();
@@ -2234,6 +2321,9 @@ app.post(routePath(BASE_PATH, '/api/settings'), express.json(), async (req, res)
     }
   }
   configManager.updateSettings(settingsPatch);
+  if (changesBrowserExtension || changesBrowserConfiguration) {
+    await browserResourceManager.refreshCapability();
+  }
   agentSessionsCache.invalidate();
   res.json({
     success: true,
@@ -2857,7 +2947,6 @@ const pendingAgentUpdates = new Map();
 const pendingSessionStreams = new Map();
 let sessionStreamBroadcastTimer = null;
 let lastSessionStreamBroadcastAt = 0;
-let shutdownStarted = false;
 
 function broadcastState() {
   lastStateBroadcastAt = Date.now();
@@ -3072,106 +3161,6 @@ function scheduleSessionStreamBroadcast(stream) {
   }
 }
 
-function clearBroadcastTimers() {
-  if (stateBroadcastTimer) {
-    clearTimeout(stateBroadcastTimer);
-    stateBroadcastTimer = null;
-  }
-  for (const entry of pendingPreviewBroadcasts.values()) {
-    if (entry && entry.timer) {
-      clearTimeout(entry.timer);
-    }
-  }
-  pendingPreviewBroadcasts.clear();
-  for (const entry of pendingAgentActivityBroadcasts.values()) {
-    if (entry && entry.timer) clearTimeout(entry.timer);
-  }
-  pendingAgentActivityBroadcasts.clear();
-  for (const entry of pendingAgentUpdates.values()) {
-    if (entry && entry.timer) clearTimeout(entry.timer);
-  }
-  pendingAgentUpdates.clear();
-  if (sessionStreamBroadcastTimer) {
-    clearTimeout(sessionStreamBroadcastTimer);
-    sessionStreamBroadcastTimer = null;
-  }
-  pendingSessionStreams.clear();
-}
-
-function closeHttpServer() {
-  return new Promise(resolve => {
-    if (!server.listening) {
-      resolve();
-      return;
-    }
-    server.close(error => {
-      if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') {
-        console.warn('Failed to close HTTP server:', error.message || error);
-      }
-      resolve();
-    });
-  });
-}
-
-function closeWebSocketServer() {
-  for (const client of wss.clients) {
-    clearWorkspaceFileWatch(client);
-    try {
-      client.close(1001, 'Farming server shutting down');
-    } catch {
-      // ignore shutdown races
-    }
-  }
-  return new Promise(resolve => {
-    wss.close(() => resolve());
-    setTimeout(resolve, 250).unref?.();
-  });
-}
-
-async function shutdownServer(options = {}) {
-  if (shutdownStarted) return;
-  shutdownStarted = true;
-  const preserveTerminalHost = options.preserveTerminalHost !== undefined
-    ? options.preserveTerminalHost === true
-    : process.env.FARMING_NATIVE_PTY_HOST_PERSIST !== '0';
-
-  try {
-    await browserResourceManager.dispose();
-    await agentManager.dispose({ preserveTerminalHost });
-  } catch (error) {
-    const teardownFrozen = agentManager.disposing === true;
-    shutdownStarted = false;
-    console.error('Farming shutdown blocked because runtime cleanup could not be verified:', error);
-    if (teardownFrozen) {
-      clearBroadcastTimers();
-      tokenAuth.cleanup();
-      await Promise.allSettled([
-        closeWebSocketServer(),
-        workspaceFileService.dispose(),
-        closeHttpServer(),
-      ]);
-    }
-    if (options.exit === true) process.exitCode = 1;
-    return {
-      error: error?.message || 'Runtime cleanup could not be verified',
-      ...(teardownFrozen ? { frozen: true } : {}),
-    };
-  }
-
-  clearBroadcastTimers();
-  tokenAuth.cleanup();
-  await Promise.allSettled([
-    closeWebSocketServer(),
-    workspaceFileService.dispose(),
-    closeHttpServer(),
-  ]);
-
-  if (options.exit === true) {
-    process.exit(options.exitCode || 0);
-  }
-  return { stopped: true };
-}
-
 agentManager.onSessionStream((stream) => {
   scheduleSessionStreamBroadcast(stream);
 });
@@ -3221,8 +3210,10 @@ function startServer() {
   if (serverStarted) return server;
   serverStarted = true;
 
-  void runTerminalRuntimeStartupCleanup().finally(() => {
-    if (shutdownStarted) return;
+  void Promise.all([
+    runTerminalRuntimeStartupCleanup(),
+    browserRuntimeRecoveryPromise,
+  ]).finally(() => {
     server.listen(PORT, () => {
       const token = tokenAuth.getToken();
       const localIPs = getLocalIPs();
@@ -3252,13 +3243,6 @@ function startServer() {
     });
   });
 
-  process.on('SIGINT', () => {
-    void shutdownServer({ exit: true });
-  });
-  process.on('SIGTERM', () => {
-    void shutdownServer({ exit: true });
-  });
-
   return server;
 }
 
@@ -3279,6 +3263,5 @@ module.exports = {
   rewriteIndexHtmlForBasePath,
   appendIndexHtmlAssetToken,
   startServer,
-  shutdownServer,
   runTerminalRuntimeStartupCleanup,
 };

package/backend/slash-command-discovery.js

@@ -159,6 +159,7 @@ function discoverClaudeSkillCommands(commands, skillsDir, sourceLabel) {
       label: commandLabel(entry.name),
       description: `Claude skill from ${sourceLabel}`,
       source: 'skill',
+      scope: sourceLabel === 'home' ? 'Personal' : commandLabel(sourceLabel),
     });
   });
 }
@@ -180,10 +181,100 @@ function discoverClaudeCustomCommands(commands, commandsDir, sourceLabel) {
       label: commandLabel(name),
       description: `Claude custom command from ${sourceLabel}`,
       source: 'custom',
+      scope: sourceLabel === 'home' ? 'Personal' : commandLabel(sourceLabel),
     });
   });
 }
 
+function discoverClaudePluginComponents(commands, pluginPath, pluginName) {
+  discoverSkillFiles(path.join(pluginPath, 'skills')).forEach(skillFile => {
+    const skillName = path.basename(path.dirname(skillFile));
+    const metadata = parseSkillFrontMatter(skillFile);
+    addCommand(commands, {
+      command: `/${pluginName}:${skillName}`,
+      label: commandLabel(metadata.name || skillName),
+      description: metadata.description || `Claude skill from ${pluginName}`,
+      source: 'skill',
+      scope: 'Plugin',
+    });
+  });
+
+  let commandEntries = [];
+  try {
+    commandEntries = fs.readdirSync(path.join(pluginPath, 'commands'), { withFileTypes: true });
+  } catch {
+    // Plugins do not have to provide commands.
+  }
+  commandEntries.forEach(entry => {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) return;
+    const commandName = entry.name.slice(0, -3);
+    if (!SAFE_COMMAND_NAME.test(commandName)) return;
+    addCommand(commands, {
+      command: `/${pluginName}:${commandName}`,
+      label: commandLabel(commandName),
+      description: `Claude command from ${pluginName}`,
+      source: 'custom',
+      scope: 'Plugin',
+    });
+  });
+}
+
+function readBoundedJson(filePath, maxBytes = 1024 * 1024) {
+  try {
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile() || stats.size > maxBytes) return null;
+    const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function addClaudePlugin(commands, pluginName, pluginPath, scope = 'Plugin') {
+  if (!SAFE_COMMAND_NAME.test(pluginName)) return;
+  const manifest = readBoundedJson(path.join(pluginPath, '.claude-plugin', 'plugin.json'));
+  addCommand(commands, {
+    command: `plugin:${pluginName}`,
+    label: String(manifest?.name || commandLabel(pluginName)).slice(0, 100),
+    description: String(manifest?.description || 'Claude Code plugin').slice(0, 500),
+    source: 'plugin',
+    scope,
+  });
+  discoverClaudePluginComponents(commands, pluginPath, pluginName);
+}
+
+function discoverClaudeInstalledPlugins(commands, homePath) {
+  const pluginsRoot = path.join(homePath, 'plugins');
+  const installed = readBoundedJson(path.join(pluginsRoot, 'installed_plugins.json'));
+  Object.entries(installed?.plugins || {}).slice(0, MAX_DISCOVERED_SKILLS).forEach(([key, rawEntries]) => {
+    const pluginName = key.split('@')[0];
+    const entries = Array.isArray(rawEntries) ? rawEntries : [];
+    const installedEntry = entries.find(entry => (
+      entry && typeof entry === 'object' && typeof entry.installPath === 'string'
+    ));
+    if (!installedEntry) return;
+    addClaudePlugin(
+      commands,
+      pluginName,
+      installedEntry.installPath,
+      String(installedEntry.scope || 'Plugin'),
+    );
+  });
+
+  let entries = [];
+  try {
+    entries = fs.readdirSync(pluginsRoot, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.forEach(entry => {
+    if (!entry.isDirectory() || !SAFE_COMMAND_NAME.test(entry.name)) return;
+    const pluginPath = path.join(pluginsRoot, entry.name);
+    if (!fs.existsSync(path.join(pluginPath, '.claude-plugin', 'plugin.json'))) return;
+    addClaudePlugin(commands, entry.name, pluginPath);
+  });
+}
+
 function discoverClaudeSlashCommands({ homeDir = os.homedir(), workspace } = {}) {
   const commands = [];
   const normalizedWorkspace = normalizeWorkspace(workspace, homeDir);
@@ -249,15 +340,26 @@ function discoverPluginSkillFiles(root, depth = 0, skillFiles = []) {
 
 function pluginNameForSkillFile(skillFile, pluginsCacheDir) {
   const parts = path.relative(pluginsCacheDir, skillFile).split(path.sep);
-  if (parts[0] === 'openai-curated' && parts[1]) return parts[1];
+  if ((parts[0] === 'openai-curated' || parts[0] === 'openai-curated-remote') && parts[1]) return parts[1];
   if ((parts[0] === 'openai-primary-runtime' || parts[0] === 'openai-bundled') && parts[1]) return parts[1];
   return parts[0] || '';
 }
 
 function discoverCodexPluginSkills(commands, homeDir) {
   const pluginsCacheDir = path.join(homeDir, '.codex', 'plugins', 'cache');
+  discoverCodexPluginSkillsAt(commands, pluginsCacheDir);
+}
+
+function discoverCodexPluginSkillsAt(commands, pluginsCacheDir) {
   discoverPluginSkillFiles(pluginsCacheDir).forEach(skillFile => {
     const pluginName = pluginNameForSkillFile(skillFile, pluginsCacheDir);
+    addCommand(commands, {
+      command: `plugin:${pluginName}`,
+      label: commandLabel(pluginName),
+      description: 'Codex plugin',
+      source: 'plugin',
+      scope: 'Plugin',
+    });
     addSkillMention(commands, skillFile, {
       mentionPrefix: pluginName,
       fallbackName: path.basename(path.dirname(skillFile)),
@@ -278,6 +380,40 @@ function discoverCodexSkillMentions({ homeDir = os.homedir(), workspace } = {})
   return commands.slice(0, MAX_DISCOVERED_SKILLS);
 }
 
+function discoverAgentExtensions({
+  provider,
+  providerHomePath,
+  workspace,
+  homeDir = os.homedir(),
+} = {}) {
+  const normalizedProvider = normalizeProvider(provider);
+  const homePath = normalizeWorkspace(providerHomePath);
+  const normalizedHomeDir = normalizeWorkspace(homeDir) || os.homedir();
+  if (!normalizedProvider || !homePath) return [];
+
+  const commands = [];
+  if (normalizedProvider === 'claude') {
+    const normalizedWorkspace = normalizeWorkspace(workspace);
+    if (normalizedWorkspace) {
+      discoverClaudeSkillCommands(commands, path.join(normalizedWorkspace, '.claude', 'skills'), 'workspace');
+      discoverClaudeCustomCommands(commands, path.join(normalizedWorkspace, '.claude', 'commands'), 'workspace');
+    }
+    discoverClaudeSkillCommands(commands, path.join(homePath, 'skills'), 'home');
+    discoverClaudeCustomCommands(commands, path.join(homePath, 'commands'), 'home');
+    discoverClaudeInstalledPlugins(commands, homePath);
+    return commands.slice(0, MAX_DISCOVERED_SKILLS);
+  }
+
+  workspaceSkillRoots(workspace, normalizedHomeDir)
+    .forEach(root => discoverDirectCodexSkills(commands, root, 'Repo'));
+  discoverDirectCodexSkills(commands, path.join(normalizedHomeDir, '.agents', 'skills'), 'Personal');
+  discoverDirectCodexSkills(commands, path.join(homePath, 'skills'), 'Personal');
+  discoverDirectCodexSkills(commands, path.join(homePath, 'skills', '.system'), 'System');
+  discoverDirectCodexSkills(commands, path.join('/etc', 'codex', 'skills'), 'Admin');
+  discoverCodexPluginSkillsAt(commands, path.join(homePath, 'plugins', 'cache'));
+  return commands.slice(0, MAX_DISCOVERED_SKILLS);
+}
+
 function discoverSlashCommands({ provider, homeDir = os.homedir(), workspace } = {}) {
   const normalizedProvider = normalizeProvider(provider);
   if (normalizedProvider === 'codex') {
@@ -290,6 +426,7 @@ function discoverSlashCommands({ provider, homeDir = os.homedir(), workspace } =
 }
 
 module.exports = {
+  discoverAgentExtensions,
   discoverSlashCommands,
   discoverClaudeSlashCommands,
   discoverCodexSkillMentions,