elsabro 2.3.0 → 3.7.0

package/references/ide-integrations.md

@@ -0,0 +1,3513 @@
+# ELSABRO v3.7 - IDE Integrations
+
+> Sistema de integracion con IDEs para orquestacion de agentes AI
+
+## Arquitectura General
+
+```
++------------------------------------------------------------------+
+|                    ELSABRO IDE INTEGRATION LAYER                  |
++------------------------------------------------------------------+
+|                                                                    |
+|  +------------------+  +------------------+  +------------------+  |
+|  |   VSCode Ext     |  | JetBrains Plugin |  |   LSP Server     |  |
+|  |   (TypeScript)   |  |    (Kotlin)      |  |   (Universal)    |  |
+|  +--------+---------+  +--------+---------+  +--------+---------+  |
+|           |                     |                     |            |
+|           +----------+----------+----------+----------+            |
+|                      |                     |                       |
+|              +-------v-------+     +-------v-------+               |
+|              | Extension API |     |  LSP Protocol |               |
+|              +-------+-------+     +-------+-------+               |
+|                      |                     |                       |
+|                      +----------+----------+                       |
+|                                 |                                  |
+|                      +----------v----------+                       |
+|                      |   ELSABRO Core API  |                       |
+|                      |  (WebSocket/HTTP)   |                       |
+|                      +---------------------+                       |
+|                                                                    |
++------------------------------------------------------------------+
+```
+
+---
+
+## 1. VSCodeExtension
+
+### 1.1 Estructura del Proyecto
+
+```
+elsabro-vscode/
+├── .vscode/
+│   ├── launch.json
+│   └── tasks.json
+├── src/
+│   ├── extension.ts           # Entry point
+│   ├── activation.ts          # Lifecycle management
+│   ├── commands/
+│   │   ├── index.ts
+│   │   ├── runAgent.ts
+│   │   ├── configureSession.ts
+│   │   └── quickActions.ts
+│   ├── providers/
+│   │   ├── treeDataProvider.ts
+│   │   ├── codeLensProvider.ts
+│   │   ├── hoverProvider.ts
+│   │   └── completionProvider.ts
+│   ├── views/
+│   │   ├── sidebarPanel.ts
+│   │   ├── webviewPanel.ts
+│   │   └── statusBar.ts
+│   ├── lsp/
+│   │   └── client.ts
+│   ├── services/
+│   │   ├── elsabroClient.ts
+│   │   ├── sessionManager.ts
+│   │   └── configManager.ts
+│   └── utils/
+│       ├── logger.ts
+│       └── constants.ts
+├── media/
+│   ├── icons/
+│   └── webview/
+├── package.json
+├── tsconfig.json
+└── webpack.config.js
+```
+
+### 1.2 Package.json Configuration
+
+```json
+{
+  "name": "elsabro-vscode",
+  "displayName": "ELSABRO AI Orchestration",
+  "description": "AI Agent orchestration for development workflows",
+  "version": "3.7.0",
+  "publisher": "elsabro",
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": ["AI", "Other"],
+  "activationEvents": [
+    "onStartupFinished",
+    "workspaceContains:.elsabro",
+    "onCommand:elsabro.*"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "elsabro.runAgent",
+        "title": "Run Agent",
+        "category": "ELSABRO",
+        "icon": "$(play)"
+      },
+      {
+        "command": "elsabro.pauseAgent",
+        "title": "Pause Agent",
+        "category": "ELSABRO",
+        "icon": "$(debug-pause)"
+      },
+      {
+        "command": "elsabro.cancelTask",
+        "title": "Cancel Task",
+        "category": "ELSABRO",
+        "icon": "$(stop)"
+      },
+      {
+        "command": "elsabro.configure",
+        "title": "Configure ELSABRO",
+        "category": "ELSABRO",
+        "icon": "$(gear)"
+      },
+      {
+        "command": "elsabro.showPanel",
+        "title": "Show ELSABRO Panel",
+        "category": "ELSABRO"
+      },
+      {
+        "command": "elsabro.generateTests",
+        "title": "Generate Tests",
+        "category": "ELSABRO"
+      },
+      {
+        "command": "elsabro.generateDocs",
+        "title": "Generate Documentation",
+        "category": "ELSABRO"
+      },
+      {
+        "command": "elsabro.refactor",
+        "title": "AI Refactor",
+        "category": "ELSABRO"
+      }
+    ],
+    "views": {
+      "elsabro-sidebar": [
+        {
+          "id": "elsabro.agentsView",
+          "name": "Agents",
+          "icon": "media/icons/agent.svg",
+          "contextualTitle": "ELSABRO Agents"
+        },
+        {
+          "id": "elsabro.tasksView",
+          "name": "Tasks",
+          "icon": "media/icons/task.svg"
+        },
+        {
+          "id": "elsabro.logsView",
+          "name": "Logs",
+          "icon": "media/icons/log.svg"
+        }
+      ]
+    },
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "elsabro-sidebar",
+          "title": "ELSABRO",
+          "icon": "media/icons/elsabro.svg"
+        }
+      ]
+    },
+    "menus": {
+      "editor/context": [
+        {
+          "command": "elsabro.runAgent",
+          "group": "elsabro@1",
+          "when": "editorHasSelection"
+        },
+        {
+          "command": "elsabro.generateTests",
+          "group": "elsabro@2"
+        },
+        {
+          "command": "elsabro.refactor",
+          "group": "elsabro@3"
+        }
+      ],
+      "view/title": [
+        {
+          "command": "elsabro.configure",
+          "when": "view == elsabro.agentsView",
+          "group": "navigation"
+        }
+      ],
+      "view/item/context": [
+        {
+          "command": "elsabro.runAgent",
+          "when": "viewItem == agent",
+          "group": "inline"
+        },
+        {
+          "command": "elsabro.cancelTask",
+          "when": "viewItem == runningTask",
+          "group": "inline"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "ELSABRO",
+      "properties": {
+        "elsabro.serverUrl": {
+          "type": "string",
+          "default": "ws://localhost:3847",
+          "description": "ELSABRO server WebSocket URL"
+        },
+        "elsabro.autoConnect": {
+          "type": "boolean",
+          "default": true,
+          "description": "Auto-connect on startup"
+        },
+        "elsabro.showInlineAnnotations": {
+          "type": "boolean",
+          "default": true,
+          "description": "Show inline code annotations"
+        },
+        "elsabro.logLevel": {
+          "type": "string",
+          "enum": ["debug", "info", "warn", "error"],
+          "default": "info"
+        }
+      }
+    },
+    "keybindings": [
+      {
+        "command": "elsabro.runAgent",
+        "key": "ctrl+shift+e r",
+        "mac": "cmd+shift+e r",
+        "when": "editorTextFocus"
+      },
+      {
+        "command": "elsabro.showPanel",
+        "key": "ctrl+shift+e p",
+        "mac": "cmd+shift+e p"
+      },
+      {
+        "command": "elsabro.generateTests",
+        "key": "ctrl+shift+e t",
+        "mac": "cmd+shift+e t",
+        "when": "editorTextFocus"
+      }
+    ]
+  }
+}
+```
+
+### 1.3 Extension Entry Point (extension.ts)
+
+```typescript
+// src/extension.ts
+import * as vscode from 'vscode';
+import { ElsabroClient } from './services/elsabroClient';
+import { SessionManager } from './services/sessionManager';
+import { AgentsTreeProvider } from './providers/treeDataProvider';
+import { ElsabroCodeLensProvider } from './providers/codeLensProvider';
+import { ElsabroHoverProvider } from './providers/hoverProvider';
+import { StatusBarManager } from './views/statusBar';
+import { SidebarPanel } from './views/sidebarPanel';
+import { registerCommands } from './commands';
+import { Logger } from './utils/logger';
+
+let client: ElsabroClient;
+let sessionManager: SessionManager;
+
+export async function activate(
+  context: vscode.ExtensionContext
+): Promise<void> {
+  Logger.info('ELSABRO extension activating...');
+
+  // Initialize core services
+  client = new ElsabroClient(context);
+  sessionManager = new SessionManager(client);
+
+  // Register providers
+  const agentsProvider = new AgentsTreeProvider(sessionManager);
+  const codeLensProvider = new ElsabroCodeLensProvider(sessionManager);
+  const hoverProvider = new ElsabroHoverProvider(sessionManager);
+
+  // Register tree views
+  context.subscriptions.push(
+    vscode.window.registerTreeDataProvider(
+      'elsabro.agentsView',
+      agentsProvider
+    )
+  );
+
+  // Register CodeLens provider
+  context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider(
+      { scheme: 'file' },
+      codeLensProvider
+    )
+  );
+
+  // Register Hover provider
+  context.subscriptions.push(
+    vscode.languages.registerHoverProvider(
+      { scheme: 'file' },
+      hoverProvider
+    )
+  );
+
+  // Initialize status bar
+  const statusBar = new StatusBarManager(context, sessionManager);
+  statusBar.initialize();
+
+  // Register all commands
+  registerCommands(context, client, sessionManager);
+
+  // Auto-connect if configured
+  const config = vscode.workspace.getConfiguration('elsabro');
+  if (config.get<boolean>('autoConnect')) {
+    await client.connect();
+  }
+
+  Logger.info('ELSABRO extension activated successfully');
+}
+
+export function deactivate(): void {
+  Logger.info('ELSABRO extension deactivating...');
+  client?.disconnect();
+}
+```
+
+### 1.4 ELSABRO Client Service
+
+```typescript
+// src/services/elsabroClient.ts
+import * as vscode from 'vscode';
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import { Logger } from '../utils/logger';
+
+interface ElsabroMessage {
+  type: string;
+  payload: any;
+  requestId?: string;
+}
+
+interface AgentStatus {
+  id: string;
+  name: string;
+  status: 'idle' | 'running' | 'paused' | 'error';
+  currentTask?: string;
+  progress?: number;
+}
+
+export class ElsabroClient extends EventEmitter {
+  private ws: WebSocket | null = null;
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 5;
+  private pendingRequests = new Map<string, {
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+    timeout: NodeJS.Timeout;
+  }>();
+
+  constructor(private context: vscode.ExtensionContext) {
+    super();
+  }
+
+  async connect(): Promise<void> {
+    const config = vscode.workspace.getConfiguration('elsabro');
+    const serverUrl = config.get<string>('serverUrl') || 'ws://localhost:3847';
+
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(serverUrl);
+
+        this.ws.on('open', () => {
+          Logger.info(`Connected to ELSABRO server: ${serverUrl}`);
+          this.reconnectAttempts = 0;
+          this.emit('connected');
+          resolve();
+        });
+
+        this.ws.on('message', (data: WebSocket.Data) => {
+          this.handleMessage(data.toString());
+        });
+
+        this.ws.on('close', () => {
+          Logger.warn('Connection closed');
+          this.emit('disconnected');
+          this.attemptReconnect();
+        });
+
+        this.ws.on('error', (error) => {
+          Logger.error(`WebSocket error: ${error.message}`);
+          this.emit('error', error);
+          reject(error);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  disconnect(): void {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  private handleMessage(data: string): void {
+    try {
+      const message: ElsabroMessage = JSON.parse(data);
+
+      // Handle response to pending request
+      if (message.requestId && this.pendingRequests.has(message.requestId)) {
+        const pending = this.pendingRequests.get(message.requestId)!;
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message.requestId);
+        pending.resolve(message.payload);
+        return;
+      }
+
+      // Handle server-initiated messages
+      switch (message.type) {
+        case 'agent:status':
+          this.emit('agentStatus', message.payload as AgentStatus);
+          break;
+        case 'task:progress':
+          this.emit('taskProgress', message.payload);
+          break;
+        case 'task:complete':
+          this.emit('taskComplete', message.payload);
+          break;
+        case 'task:error':
+          this.emit('taskError', message.payload);
+          break;
+        case 'log':
+          this.emit('log', message.payload);
+          break;
+        case 'annotation':
+          this.emit('annotation', message.payload);
+          break;
+        default:
+          Logger.debug(`Unknown message type: ${message.type}`);
+      }
+    } catch (error) {
+      Logger.error(`Failed to parse message: ${error}`);
+    }
+  }
+
+  async send<T = any>(type: string, payload: any): Promise<T> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Not connected to ELSABRO server');
+    }
+
+    const requestId = this.generateRequestId();
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error('Request timeout'));
+      }, 30000);
+
+      this.pendingRequests.set(requestId, { resolve, reject, timeout });
+
+      const message: ElsabroMessage = { type, payload, requestId };
+      this.ws!.send(JSON.stringify(message));
+    });
+  }
+
+  // Agent operations
+  async runAgent(agentId: string, params: any): Promise<string> {
+    return this.send('agent:run', { agentId, params });
+  }
+
+  async pauseAgent(agentId: string): Promise<void> {
+    return this.send('agent:pause', { agentId });
+  }
+
+  async cancelTask(taskId: string): Promise<void> {
+    return this.send('task:cancel', { taskId });
+  }
+
+  async getAgents(): Promise<AgentStatus[]> {
+    return this.send('agents:list', {});
+  }
+
+  async getTasks(): Promise<any[]> {
+    return this.send('tasks:list', {});
+  }
+
+  private attemptReconnect(): void {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      Logger.error('Max reconnect attempts reached');
+      return;
+    }
+
+    this.reconnectAttempts++;
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+
+    Logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+
+    setTimeout(() => {
+      this.connect().catch(() => {});
+    }, delay);
+  }
+
+  private generateRequestId(): string {
+    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  get isConnected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+}
+```
+
+### 1.5 WebView Panel
+
+```typescript
+// src/views/webviewPanel.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class ElsabroWebviewPanel {
+  public static currentPanel: ElsabroWebviewPanel | undefined;
+  private readonly panel: vscode.WebviewPanel;
+  private disposables: vscode.Disposable[] = [];
+
+  private constructor(
+    panel: vscode.WebviewPanel,
+    private extensionUri: vscode.Uri,
+    private sessionManager: SessionManager
+  ) {
+    this.panel = panel;
+    this.panel.onDidDispose(() => this.dispose(), null, this.disposables);
+    this.panel.webview.html = this.getHtmlContent();
+    this.setupMessageHandler();
+  }
+
+  public static createOrShow(
+    extensionUri: vscode.Uri,
+    sessionManager: SessionManager
+  ): void {
+    const column = vscode.window.activeTextEditor
+      ? vscode.window.activeTextEditor.viewColumn
+      : undefined;
+
+    if (ElsabroWebviewPanel.currentPanel) {
+      ElsabroWebviewPanel.currentPanel.panel.reveal(column);
+      return;
+    }
+
+    const panel = vscode.window.createWebviewPanel(
+      'elsabroPanel',
+      'ELSABRO Dashboard',
+      column || vscode.ViewColumn.One,
+      {
+        enableScripts: true,
+        retainContextWhenHidden: true,
+        localResourceRoots: [
+          vscode.Uri.joinPath(extensionUri, 'media')
+        ]
+      }
+    );
+
+    ElsabroWebviewPanel.currentPanel = new ElsabroWebviewPanel(
+      panel,
+      extensionUri,
+      sessionManager
+    );
+  }
+
+  private setupMessageHandler(): void {
+    this.panel.webview.onDidReceiveMessage(
+      async (message) => {
+        switch (message.command) {
+          case 'runAgent':
+            await this.sessionManager.runAgent(message.agentId, message.params);
+            break;
+          case 'pauseAgent':
+            await this.sessionManager.pauseAgent(message.agentId);
+            break;
+          case 'getStatus':
+            const status = await this.sessionManager.getStatus();
+            this.panel.webview.postMessage({ type: 'status', data: status });
+            break;
+        }
+      },
+      null,
+      this.disposables
+    );
+
+    // Listen to session events
+    this.sessionManager.on('statusChanged', (status) => {
+      this.panel.webview.postMessage({ type: 'status', data: status });
+    });
+  }
+
+  private getHtmlContent(): string {
+    const scriptUri = this.panel.webview.asWebviewUri(
+      vscode.Uri.joinPath(this.extensionUri, 'media', 'webview', 'main.js')
+    );
+    const styleUri = this.panel.webview.asWebviewUri(
+      vscode.Uri.joinPath(this.extensionUri, 'media', 'webview', 'style.css')
+    );
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="Content-Security-Policy"
+        content="default-src 'none';
+                 style-src ${this.panel.webview.cspSource};
+                 script-src ${this.panel.webview.cspSource};">
+  <link href="${styleUri}" rel="stylesheet">
+  <title>ELSABRO Dashboard</title>
+</head>
+<body>
+  <div id="app">
+    <header class="dashboard-header">
+      <h1>ELSABRO Dashboard</h1>
+      <div id="connection-status" class="status-indicator"></div>
+    </header>
+
+    <main class="dashboard-content">
+      <section class="agents-section">
+        <h2>Active Agents</h2>
+        <div id="agents-list"></div>
+      </section>
+
+      <section class="tasks-section">
+        <h2>Running Tasks</h2>
+        <div id="tasks-list"></div>
+      </section>
+
+      <section class="logs-section">
+        <h2>Logs</h2>
+        <div id="logs-container"></div>
+      </section>
+    </main>
+  </div>
+  <script src="${scriptUri}"></script>
+</body>
+</html>`;
+  }
+
+  public dispose(): void {
+    ElsabroWebviewPanel.currentPanel = undefined;
+    this.panel.dispose();
+    while (this.disposables.length) {
+      const d = this.disposables.pop();
+      if (d) d.dispose();
+    }
+  }
+}
+```
+
+---
+
+## 2. JetBrainsPlugin
+
+### 2.1 Estructura del Proyecto
+
+```
+elsabro-jetbrains/
+├── src/
+│   └── main/
+│       ├── kotlin/
+│       │   └── com/elsabro/plugin/
+│       │       ├── ElsabroPlugin.kt
+│       │       ├── services/
+│       │       │   ├── ElsabroService.kt
+│       │       │   ├── SessionService.kt
+│       │       │   └── ConfigService.kt
+│       │       ├── actions/
+│       │       │   ├── RunAgentAction.kt
+│       │       │   ├── PauseAgentAction.kt
+│       │       │   └── GenerateAction.kt
+│       │       ├── toolwindow/
+│       │       │   ├── ElsabroToolWindowFactory.kt
+│       │       │   ├── AgentsPanel.kt
+│       │       │   ├── TasksPanel.kt
+│       │       │   └── LogsPanel.kt
+│       │       ├── editor/
+│       │       │   ├── ElsabroAnnotator.kt
+│       │       │   ├── ElsabroLineMarker.kt
+│       │       │   └── ElsabroInlayHintsProvider.kt
+│       │       ├── intentions/
+│       │       │   ├── GenerateTestsIntention.kt
+│       │       │   └── RefactorIntention.kt
+│       │       └── statusbar/
+│       │           └── ElsabroStatusBarWidget.kt
+│       └── resources/
+│           ├── META-INF/
+│           │   └── plugin.xml
+│           └── icons/
+├── build.gradle.kts
+└── gradle.properties
+```
+
+### 2.2 Plugin Configuration (plugin.xml)
+
+```xml
+<!-- src/main/resources/META-INF/plugin.xml -->
+<idea-plugin>
+    <id>com.elsabro.plugin</id>
+    <name>ELSABRO AI Orchestration</name>
+    <version>3.7.0</version>
+    <vendor email="support@elsabro.dev" url="https://elsabro.dev">
+        ELSABRO Team
+    </vendor>
+
+    <description><![CDATA[
+        AI Agent orchestration for development workflows.
+        Supports IntelliJ IDEA, WebStorm, PyCharm, and all JetBrains IDEs.
+    ]]></description>
+
+    <depends>com.intellij.modules.platform</depends>
+    <depends optional="true" config-file="elsabro-java.xml">
+        com.intellij.modules.java
+    </depends>
+    <depends optional="true" config-file="elsabro-kotlin.xml">
+        org.jetbrains.kotlin
+    </depends>
+
+    <extensions defaultExtensionNs="com.intellij">
+        <!-- Services -->
+        <applicationService
+            serviceImplementation="com.elsabro.plugin.services.ElsabroService"/>
+        <projectService
+            serviceImplementation="com.elsabro.plugin.services.SessionService"/>
+        <projectService
+            serviceImplementation="com.elsabro.plugin.services.ConfigService"/>
+
+        <!-- Tool Window -->
+        <toolWindow id="ELSABRO"
+                    anchor="right"
+                    icon="/icons/elsabro.svg"
+                    factoryClass="com.elsabro.plugin.toolwindow.ElsabroToolWindowFactory"/>
+
+        <!-- Editor Annotations -->
+        <annotator language=""
+                   implementationClass="com.elsabro.plugin.editor.ElsabroAnnotator"/>
+
+        <!-- Line Markers -->
+        <codeInsight.lineMarkerProvider language=""
+            implementationClass="com.elsabro.plugin.editor.ElsabroLineMarker"/>
+
+        <!-- Inlay Hints -->
+        <codeInsight.inlayProvider language=""
+            implementationClass="com.elsabro.plugin.editor.ElsabroInlayHintsProvider"/>
+
+        <!-- Status Bar Widget -->
+        <statusBarWidgetFactory id="ElsabroStatusBar"
+            implementation="com.elsabro.plugin.statusbar.ElsabroStatusBarWidgetFactory"/>
+
+        <!-- Settings -->
+        <applicationConfigurable
+            parentId="tools"
+            instance="com.elsabro.plugin.settings.ElsabroConfigurable"
+            id="com.elsabro.plugin.settings"
+            displayName="ELSABRO"/>
+
+        <!-- Notifications -->
+        <notificationGroup id="ELSABRO Notifications"
+                          displayType="BALLOON"/>
+    </extensions>
+
+    <actions>
+        <!-- Main Action Group -->
+        <group id="ElsabroActions"
+               text="ELSABRO"
+               popup="true"
+               icon="/icons/elsabro.svg">
+
+            <action id="Elsabro.RunAgent"
+                    class="com.elsabro.plugin.actions.RunAgentAction"
+                    text="Run Agent"
+                    description="Run ELSABRO agent on selection"
+                    icon="/icons/play.svg">
+                <keyboard-shortcut keymap="$default"
+                                   first-keystroke="ctrl shift E"
+                                   second-keystroke="R"/>
+            </action>
+
+            <action id="Elsabro.PauseAgent"
+                    class="com.elsabro.plugin.actions.PauseAgentAction"
+                    text="Pause Agent"
+                    icon="/icons/pause.svg">
+                <keyboard-shortcut keymap="$default"
+                                   first-keystroke="ctrl shift E"
+                                   second-keystroke="P"/>
+            </action>
+
+            <separator/>
+
+            <action id="Elsabro.GenerateTests"
+                    class="com.elsabro.plugin.actions.GenerateTestsAction"
+                    text="Generate Tests"
+                    icon="/icons/test.svg">
+                <keyboard-shortcut keymap="$default"
+                                   first-keystroke="ctrl shift E"
+                                   second-keystroke="T"/>
+            </action>
+
+            <action id="Elsabro.GenerateDocs"
+                    class="com.elsabro.plugin.actions.GenerateDocsAction"
+                    text="Generate Documentation"
+                    icon="/icons/docs.svg"/>
+
+            <action id="Elsabro.Refactor"
+                    class="com.elsabro.plugin.actions.RefactorAction"
+                    text="AI Refactor"
+                    icon="/icons/refactor.svg"/>
+
+            <separator/>
+
+            <action id="Elsabro.ShowPanel"
+                    class="com.elsabro.plugin.actions.ShowPanelAction"
+                    text="Show ELSABRO Panel"/>
+
+            <add-to-group group-id="EditorPopupMenu" anchor="last"/>
+            <add-to-group group-id="ProjectViewPopupMenu" anchor="last"/>
+        </group>
+
+        <!-- Toolbar Actions -->
+        <group id="ElsabroToolbar">
+            <reference ref="Elsabro.RunAgent"/>
+            <reference ref="Elsabro.PauseAgent"/>
+            <add-to-group group-id="MainToolBar" anchor="last"/>
+        </group>
+    </actions>
+</idea-plugin>
+```
+
+### 2.3 Main Service (ElsabroService.kt)
+
+```kotlin
+// src/main/kotlin/com/elsabro/plugin/services/ElsabroService.kt
+package com.elsabro.plugin.services
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.service
+import com.intellij.openapi.diagnostic.Logger
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import okhttp3.*
+import okio.ByteString
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+
+@Service(Service.Level.APP)
+class ElsabroService : Disposable {
+    private val LOG = Logger.getInstance(ElsabroService::class.java)
+
+    private var webSocket: WebSocket? = null
+    private val client = OkHttpClient.Builder()
+        .readTimeout(0, TimeUnit.MILLISECONDS)
+        .build()
+
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+    private val _connectionState = MutableStateFlow<ConnectionState>(ConnectionState.Disconnected)
+    val connectionState: StateFlow<ConnectionState> = _connectionState.asStateFlow()
+
+    private val _agents = MutableStateFlow<List<AgentStatus>>(emptyList())
+    val agents: StateFlow<List<AgentStatus>> = _agents.asStateFlow()
+
+    private val _tasks = MutableStateFlow<List<TaskInfo>>(emptyList())
+    val tasks: StateFlow<List<TaskInfo>> = _tasks.asStateFlow()
+
+    private val _logs = MutableSharedFlow<LogEntry>(replay = 100)
+    val logs: SharedFlow<LogEntry> = _logs.asSharedFlow()
+
+    private val pendingRequests = ConcurrentHashMap<String, CompletableDeferred<JSONObject>>()
+
+    fun connect(serverUrl: String = "ws://localhost:3847") {
+        if (_connectionState.value is ConnectionState.Connected) return
+
+        _connectionState.value = ConnectionState.Connecting
+
+        val request = Request.Builder()
+            .url(serverUrl)
+            .build()
+
+        webSocket = client.newWebSocket(request, object : WebSocketListener() {
+            override fun onOpen(webSocket: WebSocket, response: Response) {
+                LOG.info("Connected to ELSABRO server")
+                _connectionState.value = ConnectionState.Connected
+                requestInitialState()
+            }
+
+            override fun onMessage(webSocket: WebSocket, text: String) {
+                handleMessage(text)
+            }
+
+            override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+                handleMessage(bytes.utf8())
+            }
+
+            override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+                LOG.info("Connection closing: $reason")
+                webSocket.close(1000, null)
+            }
+
+            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                LOG.info("Connection closed: $reason")
+                _connectionState.value = ConnectionState.Disconnected
+            }
+
+            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+                LOG.error("Connection failed", t)
+                _connectionState.value = ConnectionState.Error(t.message ?: "Unknown error")
+                scheduleReconnect()
+            }
+        })
+    }
+
+    fun disconnect() {
+        webSocket?.close(1000, "User disconnected")
+        webSocket = null
+        _connectionState.value = ConnectionState.Disconnected
+    }
+
+    private fun handleMessage(text: String) {
+        try {
+            val json = JSONObject(text)
+            val type = json.getString("type")
+            val payload = json.optJSONObject("payload") ?: JSONObject()
+            val requestId = json.optString("requestId", null)
+
+            // Handle response to pending request
+            if (requestId != null && pendingRequests.containsKey(requestId)) {
+                pendingRequests.remove(requestId)?.complete(payload)
+                return
+            }
+
+            // Handle server-initiated messages
+            when (type) {
+                "agents:update" -> updateAgents(payload)
+                "tasks:update" -> updateTasks(payload)
+                "task:progress" -> updateTaskProgress(payload)
+                "log" -> emitLog(payload)
+                "annotation" -> handleAnnotation(payload)
+            }
+        } catch (e: Exception) {
+            LOG.error("Failed to parse message", e)
+        }
+    }
+
+    suspend fun runAgent(agentId: String, params: Map<String, Any>): String {
+        val response = sendRequest("agent:run", mapOf(
+            "agentId" to agentId,
+            "params" to params
+        ))
+        return response.getString("taskId")
+    }
+
+    suspend fun pauseAgent(agentId: String) {
+        sendRequest("agent:pause", mapOf("agentId" to agentId))
+    }
+
+    suspend fun cancelTask(taskId: String) {
+        sendRequest("task:cancel", mapOf("taskId" to taskId))
+    }
+
+    private suspend fun sendRequest(type: String, payload: Map<String, Any>): JSONObject {
+        val requestId = generateRequestId()
+        val deferred = CompletableDeferred<JSONObject>()
+        pendingRequests[requestId] = deferred
+
+        val message = JSONObject().apply {
+            put("type", type)
+            put("payload", JSONObject(payload))
+            put("requestId", requestId)
+        }
+
+        webSocket?.send(message.toString())
+            ?: throw IllegalStateException("Not connected")
+
+        return withTimeout(30_000) { deferred.await() }
+    }
+
+    private fun requestInitialState() {
+        scope.launch {
+            try {
+                sendRequest("agents:list", emptyMap())
+                sendRequest("tasks:list", emptyMap())
+            } catch (e: Exception) {
+                LOG.error("Failed to get initial state", e)
+            }
+        }
+    }
+
+    private fun updateAgents(payload: JSONObject) {
+        val agentsList = mutableListOf<AgentStatus>()
+        val agentsArray = payload.getJSONArray("agents")
+        for (i in 0 until agentsArray.length()) {
+            val agent = agentsArray.getJSONObject(i)
+            agentsList.add(AgentStatus(
+                id = agent.getString("id"),
+                name = agent.getString("name"),
+                status = AgentState.valueOf(agent.getString("status").uppercase()),
+                currentTask = agent.optString("currentTask", null),
+                progress = agent.optInt("progress", 0)
+            ))
+        }
+        _agents.value = agentsList
+    }
+
+    private fun updateTasks(payload: JSONObject) {
+        // Similar implementation for tasks
+    }
+
+    private fun updateTaskProgress(payload: JSONObject) {
+        val taskId = payload.getString("taskId")
+        val progress = payload.getInt("progress")
+        _tasks.value = _tasks.value.map { task ->
+            if (task.id == taskId) task.copy(progress = progress) else task
+        }
+    }
+
+    private fun emitLog(payload: JSONObject) {
+        scope.launch {
+            _logs.emit(LogEntry(
+                timestamp = payload.getLong("timestamp"),
+                level = payload.getString("level"),
+                message = payload.getString("message"),
+                source = payload.optString("source", "system")
+            ))
+        }
+    }
+
+    private fun handleAnnotation(payload: JSONObject) {
+        // Handle inline annotations
+    }
+
+    private fun scheduleReconnect() {
+        scope.launch {
+            delay(5000)
+            connect()
+        }
+    }
+
+    private fun generateRequestId(): String {
+        return "req_${System.currentTimeMillis()}_${(Math.random() * 1000000).toLong()}"
+    }
+
+    override fun dispose() {
+        disconnect()
+        scope.cancel()
+    }
+
+    companion object {
+        fun getInstance(): ElsabroService = service()
+    }
+}
+
+sealed class ConnectionState {
+    object Disconnected : ConnectionState()
+    object Connecting : ConnectionState()
+    object Connected : ConnectionState()
+    data class Error(val message: String) : ConnectionState()
+}
+
+data class AgentStatus(
+    val id: String,
+    val name: String,
+    val status: AgentState,
+    val currentTask: String?,
+    val progress: Int
+)
+
+enum class AgentState {
+    IDLE, RUNNING, PAUSED, ERROR
+}
+
+data class TaskInfo(
+    val id: String,
+    val name: String,
+    val agentId: String,
+    val status: String,
+    val progress: Int,
+    val startTime: Long
+)
+
+data class LogEntry(
+    val timestamp: Long,
+    val level: String,
+    val message: String,
+    val source: String
+)
+```
+
+### 2.4 Tool Window Factory
+
+```kotlin
+// src/main/kotlin/com/elsabro/plugin/toolwindow/ElsabroToolWindowFactory.kt
+package com.elsabro.plugin.toolwindow
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.wm.ToolWindow
+import com.intellij.openapi.wm.ToolWindowFactory
+import com.intellij.ui.content.ContentFactory
+
+class ElsabroToolWindowFactory : ToolWindowFactory {
+
+    override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
+        val contentFactory = ContentFactory.getInstance()
+
+        // Agents Panel
+        val agentsPanel = AgentsPanel(project)
+        val agentsContent = contentFactory.createContent(
+            agentsPanel.component,
+            "Agents",
+            false
+        )
+        toolWindow.contentManager.addContent(agentsContent)
+
+        // Tasks Panel
+        val tasksPanel = TasksPanel(project)
+        val tasksContent = contentFactory.createContent(
+            tasksPanel.component,
+            "Tasks",
+            false
+        )
+        toolWindow.contentManager.addContent(tasksContent)
+
+        // Logs Panel
+        val logsPanel = LogsPanel(project)
+        val logsContent = contentFactory.createContent(
+            logsPanel.component,
+            "Logs",
+            false
+        )
+        toolWindow.contentManager.addContent(logsContent)
+    }
+
+    override fun shouldBeAvailable(project: Project): Boolean = true
+}
+```
+
+### 2.5 Run Agent Action
+
+```kotlin
+// src/main/kotlin/com/elsabro/plugin/actions/RunAgentAction.kt
+package com.elsabro.plugin.actions
+
+import com.elsabro.plugin.services.ElsabroService
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.ui.DialogWrapper
+import com.intellij.openapi.ui.Messages
+import kotlinx.coroutines.*
+import javax.swing.*
+
+class RunAgentAction : AnAction() {
+
+    override fun actionPerformed(e: AnActionEvent) {
+        val project = e.project ?: return
+        val editor = e.getData(CommonDataKeys.EDITOR)
+        val file = e.getData(CommonDataKeys.VIRTUAL_FILE)
+
+        val service = ElsabroService.getInstance()
+
+        // Get selected text or current file
+        val selection = editor?.selectionModel?.selectedText
+        val filePath = file?.path
+
+        // Show agent selection dialog
+        val dialog = AgentSelectionDialog(project, service)
+        if (dialog.showAndGet()) {
+            val agentId = dialog.selectedAgent ?: return
+
+            CoroutineScope(Dispatchers.Main).launch {
+                try {
+                    val taskId = service.runAgent(agentId, mapOf(
+                        "selection" to (selection ?: ""),
+                        "filePath" to (filePath ?: ""),
+                        "projectPath" to project.basePath
+                    ))
+
+                    Messages.showInfoMessage(
+                        project,
+                        "Task started: $taskId",
+                        "ELSABRO"
+                    )
+                } catch (ex: Exception) {
+                    Messages.showErrorDialog(
+                        project,
+                        "Failed to run agent: ${ex.message}",
+                        "ELSABRO Error"
+                    )
+                }
+            }
+        }
+    }
+
+    override fun update(e: AnActionEvent) {
+        val service = ElsabroService.getInstance()
+        e.presentation.isEnabled = service.connectionState.value is
+            com.elsabro.plugin.services.ConnectionState.Connected
+    }
+}
+
+class AgentSelectionDialog(
+    project: com.intellij.openapi.project.Project,
+    private val service: ElsabroService
+) : DialogWrapper(project) {
+
+    var selectedAgent: String? = null
+    private val agentList = JList<String>()
+
+    init {
+        title = "Select Agent"
+        init()
+        loadAgents()
+    }
+
+    private fun loadAgents() {
+        val agents = service.agents.value
+        agentList.setListData(agents.map { it.name }.toTypedArray())
+    }
+
+    override fun createCenterPanel(): JComponent {
+        return JPanel().apply {
+            layout = BoxLayout(this, BoxLayout.Y_AXIS)
+            add(JLabel("Select an agent to run:"))
+            add(JScrollPane(agentList))
+        }
+    }
+
+    override fun doOKAction() {
+        val agents = service.agents.value
+        val selectedIndex = agentList.selectedIndex
+        if (selectedIndex >= 0) {
+            selectedAgent = agents[selectedIndex].id
+        }
+        super.doOKAction()
+    }
+}
+```
+
+---
+
+## 3. LSPServer
+
+### 3.1 Arquitectura LSP
+
+```
++------------------------------------------------------------------+
+|                      LSP Server Architecture                      |
++------------------------------------------------------------------+
+|                                                                    |
+|  +-------------+     +------------------+     +----------------+   |
+|  |   Editor    |<--->|   LSP Transport  |<--->|  LSP Server    |   |
+|  | (Any IDE)   |     | (stdio/socket)   |     |  (Node.js)     |   |
+|  +-------------+     +------------------+     +-------+--------+   |
+|                                                       |            |
+|                                               +-------v--------+   |
+|                                               | ELSABRO Client |   |
+|                                               +----------------+   |
+|                                                                    |
++------------------------------------------------------------------+
+
+Standard LSP Capabilities:
+- textDocument/completion
+- textDocument/hover
+- textDocument/codeAction
+- textDocument/codeLens
+- textDocument/diagnostic
+
+Custom ELSABRO Requests:
+- elsabro/runAgent
+- elsabro/getAgents
+- elsabro/getTasks
+- elsabro/cancelTask
+```
+
+### 3.2 LSP Server Implementation
+
+```typescript
+// lsp-server/src/server.ts
+import {
+  createConnection,
+  TextDocuments,
+  ProposedFeatures,
+  InitializeParams,
+  InitializeResult,
+  TextDocumentSyncKind,
+  CompletionItem,
+  CompletionItemKind,
+  Hover,
+  CodeAction,
+  CodeActionKind,
+  CodeLens,
+  Diagnostic,
+  DiagnosticSeverity,
+  Connection,
+} from 'vscode-languageserver/node';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { ElsabroClient } from './elsabroClient';
+
+// Create LSP connection
+const connection: Connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+let elsabroClient: ElsabroClient;
+let hasConfigurationCapability = false;
+let hasWorkspaceFolderCapability = false;
+
+// Initialize
+connection.onInitialize((params: InitializeParams): InitializeResult => {
+  const capabilities = params.capabilities;
+
+  hasConfigurationCapability = !!(
+    capabilities.workspace && !!capabilities.workspace.configuration
+  );
+  hasWorkspaceFolderCapability = !!(
+    capabilities.workspace && !!capabilities.workspace.workspaceFolders
+  );
+
+  const result: InitializeResult = {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+
+      // Completion
+      completionProvider: {
+        resolveProvider: true,
+        triggerCharacters: ['@', '/'],
+      },
+
+      // Hover
+      hoverProvider: true,
+
+      // Code Actions
+      codeActionProvider: {
+        codeActionKinds: [
+          CodeActionKind.QuickFix,
+          CodeActionKind.Refactor,
+          CodeActionKind.Source,
+        ],
+      },
+
+      // Code Lens
+      codeLensProvider: {
+        resolveProvider: true,
+      },
+
+      // Execute Command
+      executeCommandProvider: {
+        commands: [
+          'elsabro.runAgent',
+          'elsabro.generateTests',
+          'elsabro.generateDocs',
+          'elsabro.refactor',
+        ],
+      },
+    },
+  };
+
+  if (hasWorkspaceFolderCapability) {
+    result.capabilities.workspace = {
+      workspaceFolders: {
+        supported: true,
+      },
+    };
+  }
+
+  return result;
+});
+
+connection.onInitialized(async () => {
+  // Initialize ELSABRO client
+  elsabroClient = new ElsabroClient();
+  await elsabroClient.connect();
+
+  // Listen for agent events
+  elsabroClient.on('annotation', (annotation) => {
+    sendDiagnostics(annotation);
+  });
+
+  connection.console.log('ELSABRO LSP Server initialized');
+});
+
+// Completion
+connection.onCompletion((params): CompletionItem[] => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+
+  const text = document.getText();
+  const offset = document.offsetAt(params.position);
+  const linePrefix = text.substring(
+    text.lastIndexOf('\n', offset - 1) + 1,
+    offset
+  );
+
+  const items: CompletionItem[] = [];
+
+  // ELSABRO command completions
+  if (linePrefix.endsWith('@elsabro')) {
+    items.push(
+      {
+        label: '@elsabro:run',
+        kind: CompletionItemKind.Function,
+        detail: 'Run ELSABRO agent',
+        insertText: '@elsabro:run ',
+      },
+      {
+        label: '@elsabro:test',
+        kind: CompletionItemKind.Function,
+        detail: 'Generate tests',
+        insertText: '@elsabro:test ',
+      },
+      {
+        label: '@elsabro:docs',
+        kind: CompletionItemKind.Function,
+        detail: 'Generate documentation',
+        insertText: '@elsabro:docs ',
+      }
+    );
+  }
+
+  // Agent name completions
+  if (linePrefix.includes('@elsabro:run ')) {
+    const agents = elsabroClient.getCachedAgents();
+    agents.forEach((agent) => {
+      items.push({
+        label: agent.name,
+        kind: CompletionItemKind.Module,
+        detail: `Agent: ${agent.id}`,
+        insertText: agent.id,
+      });
+    });
+  }
+
+  return items;
+});
+
+// Hover
+connection.onHover((params): Hover | null => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return null;
+
+  const text = document.getText();
+  const offset = document.offsetAt(params.position);
+
+  // Check for ELSABRO annotations
+  const annotation = elsabroClient.getAnnotationAt(
+    params.textDocument.uri,
+    params.position.line
+  );
+
+  if (annotation) {
+    return {
+      contents: {
+        kind: 'markdown',
+        value: [
+          `**ELSABRO ${annotation.type}**`,
+          '',
+          annotation.message,
+          '',
+          annotation.details ? `\`\`\`\n${annotation.details}\n\`\`\`` : '',
+        ].join('\n'),
+      },
+    };
+  }
+
+  return null;
+});
+
+// Code Actions
+connection.onCodeAction((params): CodeAction[] => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+
+  const actions: CodeAction[] = [];
+
+  // Generate Tests action
+  actions.push({
+    title: 'ELSABRO: Generate Tests',
+    kind: CodeActionKind.Source,
+    command: {
+      title: 'Generate Tests',
+      command: 'elsabro.generateTests',
+      arguments: [params.textDocument.uri, params.range],
+    },
+  });
+
+  // Generate Docs action
+  actions.push({
+    title: 'ELSABRO: Generate Documentation',
+    kind: CodeActionKind.Source,
+    command: {
+      title: 'Generate Documentation',
+      command: 'elsabro.generateDocs',
+      arguments: [params.textDocument.uri, params.range],
+    },
+  });
+
+  // AI Refactor action
+  if (params.range.start.line !== params.range.end.line) {
+    actions.push({
+      title: 'ELSABRO: AI Refactor',
+      kind: CodeActionKind.Refactor,
+      command: {
+        title: 'AI Refactor',
+        command: 'elsabro.refactor',
+        arguments: [params.textDocument.uri, params.range],
+      },
+    });
+  }
+
+  // Quick fixes from diagnostics
+  params.context.diagnostics
+    .filter((d) => d.source === 'elsabro')
+    .forEach((diagnostic) => {
+      if (diagnostic.data?.quickFix) {
+        actions.push({
+          title: diagnostic.data.quickFix.title,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+          edit: diagnostic.data.quickFix.edit,
+        });
+      }
+    });
+
+  return actions;
+});
+
+// Code Lens
+connection.onCodeLens((params): CodeLens[] => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+
+  const codeLenses: CodeLens[] = [];
+  const text = document.getText();
+  const lines = text.split('\n');
+
+  lines.forEach((line, index) => {
+    // Add CodeLens for functions/classes
+    if (
+      line.match(/^\s*(function|class|const\s+\w+\s*=\s*(?:async\s*)?\(|def\s+|public\s+|private\s+)/)
+    ) {
+      codeLenses.push({
+        range: {
+          start: { line: index, character: 0 },
+          end: { line: index, character: line.length },
+        },
+        command: {
+          title: 'Run Agent',
+          command: 'elsabro.runAgent',
+          arguments: [params.textDocument.uri, index],
+        },
+      });
+
+      codeLenses.push({
+        range: {
+          start: { line: index, character: 0 },
+          end: { line: index, character: line.length },
+        },
+        command: {
+          title: 'Generate Tests',
+          command: 'elsabro.generateTests',
+          arguments: [params.textDocument.uri, index],
+        },
+      });
+    }
+  });
+
+  return codeLenses;
+});
+
+// Execute Command
+connection.onExecuteCommand(async (params) => {
+  switch (params.command) {
+    case 'elsabro.runAgent':
+      const [uri, agentId] = params.arguments || [];
+      if (uri && agentId) {
+        const taskId = await elsabroClient.runAgent(agentId, {
+          uri,
+          projectPath: getWorkspaceFolder(uri),
+        });
+        connection.console.log(`Task started: ${taskId}`);
+      }
+      break;
+
+    case 'elsabro.generateTests':
+      await handleGenerateTests(params.arguments);
+      break;
+
+    case 'elsabro.generateDocs':
+      await handleGenerateDocs(params.arguments);
+      break;
+
+    case 'elsabro.refactor':
+      await handleRefactor(params.arguments);
+      break;
+  }
+});
+
+// Custom ELSABRO requests
+connection.onRequest('elsabro/runAgent', async (params: {
+  agentId: string;
+  params: any;
+}) => {
+  return elsabroClient.runAgent(params.agentId, params.params);
+});
+
+connection.onRequest('elsabro/getAgents', async () => {
+  return elsabroClient.getAgents();
+});
+
+connection.onRequest('elsabro/getTasks', async () => {
+  return elsabroClient.getTasks();
+});
+
+connection.onRequest('elsabro/cancelTask', async (params: { taskId: string }) => {
+  return elsabroClient.cancelTask(params.taskId);
+});
+
+// Helper functions
+function sendDiagnostics(annotation: any): void {
+  const diagnostics: Diagnostic[] = [{
+    severity: getSeverity(annotation.level),
+    range: {
+      start: { line: annotation.line, character: 0 },
+      end: { line: annotation.line, character: Number.MAX_SAFE_INTEGER },
+    },
+    message: annotation.message,
+    source: 'elsabro',
+    data: annotation.quickFix ? { quickFix: annotation.quickFix } : undefined,
+  }];
+
+  connection.sendDiagnostics({
+    uri: annotation.uri,
+    diagnostics,
+  });
+}
+
+function getSeverity(level: string): DiagnosticSeverity {
+  switch (level) {
+    case 'error':
+      return DiagnosticSeverity.Error;
+    case 'warning':
+      return DiagnosticSeverity.Warning;
+    case 'info':
+      return DiagnosticSeverity.Information;
+    default:
+      return DiagnosticSeverity.Hint;
+  }
+}
+
+function getWorkspaceFolder(uri: string): string | undefined {
+  // Implementation to get workspace folder
+  return undefined;
+}
+
+async function handleGenerateTests(args: any[]): Promise<void> {
+  const [uri, range] = args;
+  await elsabroClient.runAgent('test-generator', { uri, range });
+}
+
+async function handleGenerateDocs(args: any[]): Promise<void> {
+  const [uri, range] = args;
+  await elsabroClient.runAgent('doc-generator', { uri, range });
+}
+
+async function handleRefactor(args: any[]): Promise<void> {
+  const [uri, range] = args;
+  await elsabroClient.runAgent('refactoring-specialist', { uri, range });
+}
+
+// Start server
+documents.listen(connection);
+connection.listen();
+```
+
+---
+
+## 4. SidebarPanel
+
+### 4.1 TreeView Provider (VSCode)
+
+```typescript
+// src/providers/treeDataProvider.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class AgentsTreeProvider implements vscode.TreeDataProvider<TreeItem> {
+  private _onDidChangeTreeData = new vscode.EventEmitter<TreeItem | undefined>();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  constructor(private sessionManager: SessionManager) {
+    sessionManager.on('agentsChanged', () => this.refresh());
+    sessionManager.on('tasksChanged', () => this.refresh());
+  }
+
+  refresh(): void {
+    this._onDidChangeTreeData.fire(undefined);
+  }
+
+  getTreeItem(element: TreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  async getChildren(element?: TreeItem): Promise<TreeItem[]> {
+    if (!element) {
+      // Root level - show categories
+      return [
+        new CategoryItem('Agents', 'agents'),
+        new CategoryItem('Running Tasks', 'tasks'),
+        new CategoryItem('Recent', 'recent'),
+      ];
+    }
+
+    switch (element.contextValue) {
+      case 'category-agents':
+        return this.getAgentItems();
+      case 'category-tasks':
+        return this.getTaskItems();
+      case 'category-recent':
+        return this.getRecentItems();
+      default:
+        return [];
+    }
+  }
+
+  private async getAgentItems(): Promise<AgentItem[]> {
+    const agents = await this.sessionManager.getAgents();
+    return agents.map((agent) => new AgentItem(agent));
+  }
+
+  private async getTaskItems(): Promise<TaskItem[]> {
+    const tasks = await this.sessionManager.getTasks();
+    return tasks
+      .filter((t) => t.status === 'running')
+      .map((task) => new TaskItem(task));
+  }
+
+  private async getRecentItems(): Promise<TaskItem[]> {
+    const tasks = await this.sessionManager.getTasks();
+    return tasks
+      .filter((t) => t.status !== 'running')
+      .slice(0, 10)
+      .map((task) => new TaskItem(task));
+  }
+}
+
+class TreeItem extends vscode.TreeItem {
+  constructor(
+    label: string,
+    collapsibleState: vscode.TreeItemCollapsibleState
+  ) {
+    super(label, collapsibleState);
+  }
+}
+
+class CategoryItem extends TreeItem {
+  constructor(label: string, category: string) {
+    super(label, vscode.TreeItemCollapsibleState.Expanded);
+    this.contextValue = `category-${category}`;
+    this.iconPath = new vscode.ThemeIcon(this.getIcon(category));
+  }
+
+  private getIcon(category: string): string {
+    switch (category) {
+      case 'agents':
+        return 'symbol-class';
+      case 'tasks':
+        return 'play-circle';
+      case 'recent':
+        return 'history';
+      default:
+        return 'folder';
+    }
+  }
+}
+
+class AgentItem extends TreeItem {
+  constructor(agent: any) {
+    super(agent.name, vscode.TreeItemCollapsibleState.None);
+    this.contextValue = 'agent';
+    this.id = agent.id;
+    this.description = agent.status;
+    this.tooltip = `${agent.name}\nStatus: ${agent.status}`;
+    this.iconPath = new vscode.ThemeIcon(this.getStatusIcon(agent.status));
+
+    this.command = {
+      command: 'elsabro.showAgentDetails',
+      title: 'Show Details',
+      arguments: [agent.id],
+    };
+  }
+
+  private getStatusIcon(status: string): string {
+    switch (status) {
+      case 'running':
+        return 'sync~spin';
+      case 'idle':
+        return 'circle-outline';
+      case 'paused':
+        return 'debug-pause';
+      case 'error':
+        return 'error';
+      default:
+        return 'circle-outline';
+    }
+  }
+}
+
+class TaskItem extends TreeItem {
+  constructor(task: any) {
+    super(task.name, vscode.TreeItemCollapsibleState.None);
+    this.contextValue = task.status === 'running' ? 'runningTask' : 'task';
+    this.id = task.id;
+    this.description = `${task.progress}%`;
+    this.tooltip = `Task: ${task.name}\nAgent: ${task.agentId}\nProgress: ${task.progress}%`;
+    this.iconPath = new vscode.ThemeIcon(this.getStatusIcon(task.status));
+  }
+
+  private getStatusIcon(status: string): string {
+    switch (status) {
+      case 'running':
+        return 'loading~spin';
+      case 'completed':
+        return 'check';
+      case 'failed':
+        return 'error';
+      case 'cancelled':
+        return 'circle-slash';
+      default:
+        return 'circle-outline';
+    }
+  }
+}
+```
+
+### 4.2 Agents Panel (JetBrains)
+
+```kotlin
+// src/main/kotlin/com/elsabro/plugin/toolwindow/AgentsPanel.kt
+package com.elsabro.plugin.toolwindow
+
+import com.elsabro.plugin.services.AgentStatus
+import com.elsabro.plugin.services.ElsabroService
+import com.intellij.openapi.project.Project
+import com.intellij.ui.components.JBList
+import com.intellij.ui.components.JBScrollPane
+import com.intellij.util.ui.JBUI
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.collectLatest
+import java.awt.BorderLayout
+import java.awt.Component
+import javax.swing.*
+
+class AgentsPanel(private val project: Project) {
+    val component: JComponent
+    private val listModel = DefaultListModel<AgentStatus>()
+    private val agentsList = JBList(listModel)
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+    init {
+        component = JPanel(BorderLayout()).apply {
+            border = JBUI.Borders.empty(5)
+
+            // Toolbar
+            val toolbar = createToolbar()
+            add(toolbar, BorderLayout.NORTH)
+
+            // Agents list
+            agentsList.cellRenderer = AgentCellRenderer()
+            agentsList.addMouseListener(object : java.awt.event.MouseAdapter() {
+                override fun mouseClicked(e: java.awt.event.MouseEvent) {
+                    if (e.clickCount == 2) {
+                        val agent = agentsList.selectedValue
+                        if (agent != null) {
+                            runAgent(agent)
+                        }
+                    }
+                }
+            })
+            add(JBScrollPane(agentsList), BorderLayout.CENTER)
+        }
+
+        // Subscribe to agents updates
+        subscribeToAgents()
+    }
+
+    private fun createToolbar(): JPanel {
+        return JPanel().apply {
+            layout = BoxLayout(this, BoxLayout.X_AXIS)
+
+            add(JButton("Run").apply {
+                addActionListener {
+                    agentsList.selectedValue?.let { runAgent(it) }
+                }
+            })
+
+            add(Box.createHorizontalStrut(5))
+
+            add(JButton("Pause").apply {
+                addActionListener {
+                    agentsList.selectedValue?.let { pauseAgent(it) }
+                }
+            })
+
+            add(Box.createHorizontalStrut(5))
+
+            add(JButton("Refresh").apply {
+                addActionListener { refresh() }
+            })
+        }
+    }
+
+    private fun subscribeToAgents() {
+        scope.launch {
+            ElsabroService.getInstance().agents.collectLatest { agents ->
+                listModel.clear()
+                agents.forEach { listModel.addElement(it) }
+            }
+        }
+    }
+
+    private fun runAgent(agent: AgentStatus) {
+        scope.launch {
+            try {
+                ElsabroService.getInstance().runAgent(agent.id, mapOf(
+                    "projectPath" to project.basePath
+                ))
+            } catch (e: Exception) {
+                // Show error notification
+            }
+        }
+    }
+
+    private fun pauseAgent(agent: AgentStatus) {
+        scope.launch {
+            try {
+                ElsabroService.getInstance().pauseAgent(agent.id)
+            } catch (e: Exception) {
+                // Show error notification
+            }
+        }
+    }
+
+    private fun refresh() {
+        // Trigger refresh
+    }
+}
+
+class AgentCellRenderer : ListCellRenderer<AgentStatus> {
+    private val panel = JPanel(BorderLayout())
+    private val nameLabel = JLabel()
+    private val statusLabel = JLabel()
+    private val progressBar = JProgressBar()
+
+    init {
+        panel.border = JBUI.Borders.empty(5)
+
+        val textPanel = JPanel().apply {
+            layout = BoxLayout(this, BoxLayout.Y_AXIS)
+            add(nameLabel)
+            add(statusLabel)
+        }
+
+        panel.add(textPanel, BorderLayout.CENTER)
+        panel.add(progressBar, BorderLayout.SOUTH)
+    }
+
+    override fun getListCellRendererComponent(
+        list: JList<out AgentStatus>,
+        value: AgentStatus,
+        index: Int,
+        isSelected: Boolean,
+        cellHasFocus: Boolean
+    ): Component {
+        nameLabel.text = value.name
+        statusLabel.text = value.status.name.lowercase()
+        progressBar.value = value.progress
+        progressBar.isVisible = value.status == com.elsabro.plugin.services.AgentState.RUNNING
+
+        if (isSelected) {
+            panel.background = list.selectionBackground
+            nameLabel.foreground = list.selectionForeground
+            statusLabel.foreground = list.selectionForeground
+        } else {
+            panel.background = list.background
+            nameLabel.foreground = list.foreground
+            statusLabel.foreground = java.awt.Color.GRAY
+        }
+
+        return panel
+    }
+}
+```
+
+---
+
+## 5. InlineAnnotations
+
+### 5.1 CodeLens Provider (VSCode)
+
+```typescript
+// src/providers/codeLensProvider.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class ElsabroCodeLensProvider implements vscode.CodeLensProvider {
+  private _onDidChangeCodeLenses = new vscode.EventEmitter<void>();
+  readonly onDidChangeCodeLenses = this._onDidChangeCodeLenses.event;
+
+  constructor(private sessionManager: SessionManager) {
+    sessionManager.on('annotationsChanged', () => {
+      this._onDidChangeCodeLenses.fire();
+    });
+  }
+
+  provideCodeLenses(
+    document: vscode.TextDocument,
+    token: vscode.CancellationToken
+  ): vscode.CodeLens[] {
+    const codeLenses: vscode.CodeLens[] = [];
+    const text = document.getText();
+    const lines = text.split('\n');
+
+    // Pattern to match functions, classes, methods
+    const patterns = [
+      /^\s*(export\s+)?(async\s+)?function\s+(\w+)/,
+      /^\s*(export\s+)?class\s+(\w+)/,
+      /^\s*(public|private|protected)?\s*(async\s+)?(\w+)\s*\(/,
+      /^\s*const\s+(\w+)\s*=\s*(async\s*)?\(/,
+      /^\s*def\s+(\w+)\s*\(/,
+    ];
+
+    lines.forEach((line, index) => {
+      for (const pattern of patterns) {
+        if (pattern.test(line)) {
+          const range = new vscode.Range(index, 0, index, line.length);
+
+          // Run Agent CodeLens
+          codeLenses.push(
+            new vscode.CodeLens(range, {
+              title: '$(play) Run Agent',
+              command: 'elsabro.runAgent',
+              arguments: [document.uri, index],
+            })
+          );
+
+          // Generate Tests CodeLens
+          codeLenses.push(
+            new vscode.CodeLens(range, {
+              title: '$(beaker) Tests',
+              command: 'elsabro.generateTests',
+              arguments: [document.uri, index],
+            })
+          );
+
+          // Generate Docs CodeLens
+          codeLenses.push(
+            new vscode.CodeLens(range, {
+              title: '$(book) Docs',
+              command: 'elsabro.generateDocs',
+              arguments: [document.uri, index],
+            })
+          );
+
+          break;
+        }
+      }
+    });
+
+    // Add CodeLenses from active annotations
+    const annotations = this.sessionManager.getAnnotations(document.uri.toString());
+    annotations.forEach((annotation) => {
+      const range = new vscode.Range(
+        annotation.line,
+        0,
+        annotation.line,
+        document.lineAt(annotation.line).text.length
+      );
+
+      codeLenses.push(
+        new vscode.CodeLens(range, {
+          title: `$(${annotation.icon}) ${annotation.title}`,
+          command: annotation.command,
+          arguments: annotation.args,
+        })
+      );
+    });
+
+    return codeLenses;
+  }
+}
+```
+
+### 5.2 Decoration Provider (VSCode)
+
+```typescript
+// src/providers/decorationProvider.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class ElsabroDecorationProvider {
+  private decorationTypes: Map<string, vscode.TextEditorDecorationType> = new Map();
+  private disposables: vscode.Disposable[] = [];
+
+  constructor(private sessionManager: SessionManager) {
+    this.initializeDecorationTypes();
+    this.registerListeners();
+  }
+
+  private initializeDecorationTypes(): void {
+    // Warning decoration
+    this.decorationTypes.set(
+      'warning',
+      vscode.window.createTextEditorDecorationType({
+        backgroundColor: 'rgba(255, 193, 7, 0.1)',
+        borderColor: 'rgba(255, 193, 7, 0.5)',
+        borderWidth: '0 0 0 3px',
+        borderStyle: 'solid',
+        overviewRulerColor: 'rgba(255, 193, 7, 0.8)',
+        overviewRulerLane: vscode.OverviewRulerLane.Right,
+        gutterIconPath: this.getGutterIcon('warning'),
+        gutterIconSize: 'contain',
+      })
+    );
+
+    // Error decoration
+    this.decorationTypes.set(
+      'error',
+      vscode.window.createTextEditorDecorationType({
+        backgroundColor: 'rgba(244, 67, 54, 0.1)',
+        borderColor: 'rgba(244, 67, 54, 0.5)',
+        borderWidth: '0 0 0 3px',
+        borderStyle: 'solid',
+        overviewRulerColor: 'rgba(244, 67, 54, 0.8)',
+        overviewRulerLane: vscode.OverviewRulerLane.Right,
+        gutterIconPath: this.getGutterIcon('error'),
+        gutterIconSize: 'contain',
+      })
+    );
+
+    // Info decoration
+    this.decorationTypes.set(
+      'info',
+      vscode.window.createTextEditorDecorationType({
+        backgroundColor: 'rgba(33, 150, 243, 0.1)',
+        borderColor: 'rgba(33, 150, 243, 0.5)',
+        borderWidth: '0 0 0 3px',
+        borderStyle: 'solid',
+        overviewRulerColor: 'rgba(33, 150, 243, 0.8)',
+        overviewRulerLane: vscode.OverviewRulerLane.Right,
+        gutterIconPath: this.getGutterIcon('info'),
+        gutterIconSize: 'contain',
+      })
+    );
+
+    // Success decoration
+    this.decorationTypes.set(
+      'success',
+      vscode.window.createTextEditorDecorationType({
+        backgroundColor: 'rgba(76, 175, 80, 0.1)',
+        borderColor: 'rgba(76, 175, 80, 0.5)',
+        borderWidth: '0 0 0 3px',
+        borderStyle: 'solid',
+        overviewRulerColor: 'rgba(76, 175, 80, 0.8)',
+        overviewRulerLane: vscode.OverviewRulerLane.Right,
+        gutterIconPath: this.getGutterIcon('success'),
+        gutterIconSize: 'contain',
+      })
+    );
+
+    // Agent running decoration
+    this.decorationTypes.set(
+      'running',
+      vscode.window.createTextEditorDecorationType({
+        after: {
+          contentText: ' $(sync~spin) Agent running...',
+          color: 'rgba(33, 150, 243, 0.8)',
+          fontStyle: 'italic',
+        },
+      })
+    );
+  }
+
+  private getGutterIcon(type: string): vscode.Uri {
+    // Return URI to gutter icon
+    return vscode.Uri.file(`${__dirname}/../../media/icons/gutter-${type}.svg`);
+  }
+
+  private registerListeners(): void {
+    // Update decorations when annotations change
+    this.sessionManager.on('annotationsChanged', (uri: string) => {
+      this.updateDecorations(uri);
+    });
+
+    // Update decorations when editor changes
+    this.disposables.push(
+      vscode.window.onDidChangeActiveTextEditor((editor) => {
+        if (editor) {
+          this.updateDecorations(editor.document.uri.toString());
+        }
+      })
+    );
+  }
+
+  public updateDecorations(uri: string): void {
+    const editor = vscode.window.visibleTextEditors.find(
+      (e) => e.document.uri.toString() === uri
+    );
+    if (!editor) return;
+
+    const annotations = this.sessionManager.getAnnotations(uri);
+
+    // Group annotations by type
+    const grouped = new Map<string, vscode.DecorationOptions[]>();
+
+    annotations.forEach((annotation) => {
+      const type = annotation.type;
+      if (!grouped.has(type)) {
+        grouped.set(type, []);
+      }
+
+      const range = new vscode.Range(
+        annotation.line,
+        0,
+        annotation.line,
+        editor.document.lineAt(annotation.line).text.length
+      );
+
+      grouped.get(type)!.push({
+        range,
+        hoverMessage: new vscode.MarkdownString(
+          `**ELSABRO ${annotation.type.toUpperCase()}**\n\n${annotation.message}`
+        ),
+      });
+    });
+
+    // Apply decorations
+    this.decorationTypes.forEach((decorationType, typeName) => {
+      const decorations = grouped.get(typeName) || [];
+      editor.setDecorations(decorationType, decorations);
+    });
+  }
+
+  public dispose(): void {
+    this.decorationTypes.forEach((type) => type.dispose());
+    this.disposables.forEach((d) => d.dispose());
+  }
+}
+```
+
+### 5.3 Hover Provider (VSCode)
+
+```typescript
+// src/providers/hoverProvider.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class ElsabroHoverProvider implements vscode.HoverProvider {
+  constructor(private sessionManager: SessionManager) {}
+
+  provideHover(
+    document: vscode.TextDocument,
+    position: vscode.Position,
+    token: vscode.CancellationToken
+  ): vscode.Hover | null {
+    const annotations = this.sessionManager.getAnnotations(document.uri.toString());
+
+    // Find annotation at this line
+    const annotation = annotations.find((a) => a.line === position.line);
+
+    if (annotation) {
+      const markdown = new vscode.MarkdownString();
+      markdown.isTrusted = true;
+      markdown.supportHtml = true;
+
+      // Header with icon
+      markdown.appendMarkdown(`### $(${annotation.icon}) ELSABRO ${annotation.type.toUpperCase()}\n\n`);
+
+      // Message
+      markdown.appendMarkdown(`${annotation.message}\n\n`);
+
+      // Details if available
+      if (annotation.details) {
+        markdown.appendMarkdown(`---\n\n`);
+        markdown.appendCodeblock(annotation.details, annotation.language || 'text');
+      }
+
+      // Agent info
+      if (annotation.agentId) {
+        markdown.appendMarkdown(`\n\n---\n\n`);
+        markdown.appendMarkdown(`*Agent: ${annotation.agentId}*\n`);
+        markdown.appendMarkdown(`*Task: ${annotation.taskId}*`);
+      }
+
+      // Actions
+      if (annotation.actions && annotation.actions.length > 0) {
+        markdown.appendMarkdown(`\n\n---\n\n`);
+        annotation.actions.forEach((action: any) => {
+          markdown.appendMarkdown(
+            `[${action.title}](command:${action.command}?${encodeURIComponent(
+              JSON.stringify(action.args)
+            )}) `
+          );
+        });
+      }
+
+      return new vscode.Hover(markdown);
+    }
+
+    // Check for ELSABRO comments
+    const line = document.lineAt(position.line).text;
+    const elsabroCommentMatch = line.match(/@elsabro:(\w+)\s*(.*)/);
+
+    if (elsabroCommentMatch) {
+      const [, command, args] = elsabroCommentMatch;
+      const markdown = new vscode.MarkdownString();
+      markdown.isTrusted = true;
+
+      markdown.appendMarkdown(`### ELSABRO Command\n\n`);
+      markdown.appendMarkdown(`**Command:** \`${command}\`\n\n`);
+      if (args) {
+        markdown.appendMarkdown(`**Arguments:** ${args}\n\n`);
+      }
+      markdown.appendMarkdown(
+        `[Execute](command:elsabro.executeComment?${encodeURIComponent(
+          JSON.stringify({ line: position.line })
+        )})`
+      );
+
+      return new vscode.Hover(markdown);
+    }
+
+    return null;
+  }
+}
+```
+
+---
+
+## 6. QuickActions
+
+### 6.1 Code Action Provider (VSCode)
+
+```typescript
+// src/providers/codeActionProvider.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class ElsabroCodeActionProvider implements vscode.CodeActionProvider {
+  public static readonly providedCodeActionKinds = [
+    vscode.CodeActionKind.QuickFix,
+    vscode.CodeActionKind.Refactor,
+    vscode.CodeActionKind.Source,
+  ];
+
+  constructor(private sessionManager: SessionManager) {}
+
+  provideCodeActions(
+    document: vscode.TextDocument,
+    range: vscode.Range | vscode.Selection,
+    context: vscode.CodeActionContext,
+    token: vscode.CancellationToken
+  ): vscode.CodeAction[] {
+    const actions: vscode.CodeAction[] = [];
+
+    // Quick fixes from diagnostics
+    context.diagnostics
+      .filter((d) => d.source === 'elsabro')
+      .forEach((diagnostic) => {
+        const fix = this.createQuickFix(document, diagnostic);
+        if (fix) {
+          actions.push(fix);
+        }
+      });
+
+    // Refactoring actions (when there's a selection)
+    if (!range.isEmpty) {
+      actions.push(
+        this.createRefactorAction(
+          'Extract Function',
+          'elsabro.refactor.extractFunction',
+          document,
+          range
+        ),
+        this.createRefactorAction(
+          'Extract Variable',
+          'elsabro.refactor.extractVariable',
+          document,
+          range
+        ),
+        this.createRefactorAction(
+          'AI Improve',
+          'elsabro.refactor.improve',
+          document,
+          range
+        )
+      );
+    }
+
+    // Source actions (always available)
+    actions.push(
+      this.createSourceAction(
+        'Generate Tests for File',
+        'elsabro.generateTests',
+        document
+      ),
+      this.createSourceAction(
+        'Generate Documentation',
+        'elsabro.generateDocs',
+        document
+      ),
+      this.createSourceAction(
+        'Optimize Imports',
+        'elsabro.optimizeImports',
+        document
+      )
+    );
+
+    // Context-aware actions
+    const contextActions = this.getContextAwareActions(document, range);
+    actions.push(...contextActions);
+
+    return actions;
+  }
+
+  private createQuickFix(
+    document: vscode.TextDocument,
+    diagnostic: vscode.Diagnostic
+  ): vscode.CodeAction | null {
+    const data = diagnostic.data as any;
+    if (!data?.fix) return null;
+
+    const action = new vscode.CodeAction(
+      data.fix.title,
+      vscode.CodeActionKind.QuickFix
+    );
+
+    action.edit = new vscode.WorkspaceEdit();
+    action.edit.replace(document.uri, diagnostic.range, data.fix.replacement);
+    action.isPreferred = data.fix.isPreferred;
+    action.diagnostics = [diagnostic];
+
+    return action;
+  }
+
+  private createRefactorAction(
+    title: string,
+    command: string,
+    document: vscode.TextDocument,
+    range: vscode.Range
+  ): vscode.CodeAction {
+    const action = new vscode.CodeAction(
+      `ELSABRO: ${title}`,
+      vscode.CodeActionKind.Refactor
+    );
+
+    action.command = {
+      title,
+      command,
+      arguments: [document.uri, range],
+    };
+
+    return action;
+  }
+
+  private createSourceAction(
+    title: string,
+    command: string,
+    document: vscode.TextDocument
+  ): vscode.CodeAction {
+    const action = new vscode.CodeAction(
+      `ELSABRO: ${title}`,
+      vscode.CodeActionKind.Source
+    );
+
+    action.command = {
+      title,
+      command,
+      arguments: [document.uri],
+    };
+
+    return action;
+  }
+
+  private getContextAwareActions(
+    document: vscode.TextDocument,
+    range: vscode.Range
+  ): vscode.CodeAction[] {
+    const actions: vscode.CodeAction[] = [];
+    const line = document.lineAt(range.start.line).text;
+
+    // Function-specific actions
+    if (line.match(/function|const.*=.*=>|def\s+/)) {
+      actions.push(
+        this.createRefactorAction(
+          'Add Error Handling',
+          'elsabro.refactor.addErrorHandling',
+          document,
+          range
+        ),
+        this.createRefactorAction(
+          'Add Logging',
+          'elsabro.refactor.addLogging',
+          document,
+          range
+        ),
+        this.createRefactorAction(
+          'Add Input Validation',
+          'elsabro.refactor.addValidation',
+          document,
+          range
+        )
+      );
+    }
+
+    // Class-specific actions
+    if (line.match(/class\s+/)) {
+      actions.push(
+        this.createRefactorAction(
+          'Generate Getters/Setters',
+          'elsabro.generate.gettersSetters',
+          document,
+          range
+        ),
+        this.createRefactorAction(
+          'Implement Interface',
+          'elsabro.refactor.implementInterface',
+          document,
+          range
+        )
+      );
+    }
+
+    // Import-specific actions
+    if (line.match(/import|require|from/)) {
+      actions.push(
+        this.createRefactorAction(
+          'Organize Imports',
+          'elsabro.refactor.organizeImports',
+          document,
+          range
+        )
+      );
+    }
+
+    return actions;
+  }
+}
+```
+
+### 6.2 Intentions (JetBrains)
+
+```kotlin
+// src/main/kotlin/com/elsabro/plugin/intentions/GenerateTestsIntention.kt
+package com.elsabro.plugin.intentions
+
+import com.elsabro.plugin.services.ElsabroService
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class GenerateTestsIntention : PsiElementBaseIntentionAction(), IntentionAction {
+
+    override fun getText(): String = "ELSABRO: Generate Tests"
+
+    override fun getFamilyName(): String = "ELSABRO"
+
+    override fun isAvailable(project: Project, editor: Editor?, element: PsiElement): Boolean {
+        // Check if element is inside a function or class
+        return findTargetElement(element) != null
+    }
+
+    override fun invoke(project: Project, editor: Editor?, element: PsiElement) {
+        val target = findTargetElement(element) ?: return
+        val file = element.containingFile?.virtualFile?.path ?: return
+        val startLine = editor?.document?.getLineNumber(target.textRange.startOffset) ?: 0
+
+        CoroutineScope(Dispatchers.Main).launch {
+            try {
+                ElsabroService.getInstance().runAgent("test-generator", mapOf(
+                    "filePath" to file,
+                    "startLine" to startLine,
+                    "elementText" to target.text,
+                    "projectPath" to project.basePath
+                ))
+            } catch (e: Exception) {
+                // Show notification
+            }
+        }
+    }
+
+    private fun findTargetElement(element: PsiElement): PsiElement? {
+        // Language-agnostic check for function/method/class
+        var current: PsiElement? = element
+        while (current != null) {
+            val text = current.node?.elementType?.toString() ?: ""
+            if (text.contains("FUNCTION") ||
+                text.contains("METHOD") ||
+                text.contains("CLASS")) {
+                return current
+            }
+            current = current.parent
+        }
+        return null
+    }
+}
+```
+
+---
+
+## 7. StatusBarIntegration
+
+### 7.1 Status Bar Manager (VSCode)
+
+```typescript
+// src/views/statusBar.ts
+import * as vscode from 'vscode';
+import { SessionManager } from '../services/sessionManager';
+
+export class StatusBarManager {
+  private statusBarItem: vscode.StatusBarItem;
+  private progressBarItem: vscode.StatusBarItem;
+
+  constructor(
+    private context: vscode.ExtensionContext,
+    private sessionManager: SessionManager
+  ) {
+    // Main status bar item
+    this.statusBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Left,
+      100
+    );
+    this.statusBarItem.command = 'elsabro.showPanel';
+    context.subscriptions.push(this.statusBarItem);
+
+    // Progress bar item
+    this.progressBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Left,
+      99
+    );
+    context.subscriptions.push(this.progressBarItem);
+  }
+
+  initialize(): void {
+    this.updateStatusBar();
+
+    // Listen for connection changes
+    this.sessionManager.on('connectionChanged', (connected: boolean) => {
+      this.updateStatusBar();
+    });
+
+    // Listen for task updates
+    this.sessionManager.on('taskProgress', (task: any) => {
+      this.updateProgress(task);
+    });
+
+    this.sessionManager.on('taskComplete', () => {
+      this.hideProgress();
+    });
+
+    this.statusBarItem.show();
+  }
+
+  private updateStatusBar(): void {
+    const isConnected = this.sessionManager.isConnected;
+
+    if (isConnected) {
+      this.statusBarItem.text = '$(check) ELSABRO';
+      this.statusBarItem.tooltip = 'ELSABRO: Connected - Click to open panel';
+      this.statusBarItem.backgroundColor = undefined;
+    } else {
+      this.statusBarItem.text = '$(x) ELSABRO';
+      this.statusBarItem.tooltip = 'ELSABRO: Disconnected - Click to reconnect';
+      this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+        'statusBarItem.errorBackground'
+      );
+    }
+  }
+
+  private updateProgress(task: any): void {
+    this.progressBarItem.text = `$(sync~spin) ${task.name}: ${task.progress}%`;
+    this.progressBarItem.tooltip = `Task: ${task.name}\nAgent: ${task.agentId}\nProgress: ${task.progress}%`;
+    this.progressBarItem.show();
+  }
+
+  private hideProgress(): void {
+    this.progressBarItem.hide();
+  }
+
+  public setStatus(status: 'connected' | 'disconnected' | 'running' | 'error', message?: string): void {
+    const icons: Record<string, string> = {
+      connected: '$(check)',
+      disconnected: '$(x)',
+      running: '$(sync~spin)',
+      error: '$(error)',
+    };
+
+    const backgrounds: Record<string, vscode.ThemeColor | undefined> = {
+      connected: undefined,
+      disconnected: new vscode.ThemeColor('statusBarItem.warningBackground'),
+      running: undefined,
+      error: new vscode.ThemeColor('statusBarItem.errorBackground'),
+    };
+
+    this.statusBarItem.text = `${icons[status]} ELSABRO${message ? `: ${message}` : ''}`;
+    this.statusBarItem.backgroundColor = backgrounds[status];
+  }
+}
+```
+
+### 7.2 Status Bar Widget (JetBrains)
+
+```kotlin
+// src/main/kotlin/com/elsabro/plugin/statusbar/ElsabroStatusBarWidget.kt
+package com.elsabro.plugin.statusbar
+
+import com.elsabro.plugin.services.ConnectionState
+import com.elsabro.plugin.services.ElsabroService
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.wm.StatusBar
+import com.intellij.openapi.wm.StatusBarWidget
+import com.intellij.openapi.wm.StatusBarWidgetFactory
+import com.intellij.util.Consumer
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.collectLatest
+import java.awt.Component
+import java.awt.event.MouseEvent
+import javax.swing.Icon
+
+class ElsabroStatusBarWidgetFactory : StatusBarWidgetFactory {
+    override fun getId(): String = "ElsabroStatusBar"
+    override fun getDisplayName(): String = "ELSABRO"
+    override fun isAvailable(project: Project): Boolean = true
+
+    override fun createWidget(project: Project): StatusBarWidget {
+        return ElsabroStatusBarWidget(project)
+    }
+
+    override fun disposeWidget(widget: StatusBarWidget) {
+        (widget as? ElsabroStatusBarWidget)?.dispose()
+    }
+
+    override fun canBeEnabledOn(statusBar: StatusBar): Boolean = true
+}
+
+class ElsabroStatusBarWidget(
+    private val project: Project
+) : StatusBarWidget, StatusBarWidget.TextPresentation {
+
+    private var statusBar: StatusBar? = null
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private var currentText = "ELSABRO: Disconnected"
+    private var currentTooltip = "Click to connect"
+
+    init {
+        subscribeToConnectionState()
+    }
+
+    private fun subscribeToConnectionState() {
+        scope.launch {
+            ElsabroService.getInstance().connectionState.collectLatest { state ->
+                updateState(state)
+            }
+        }
+
+        scope.launch {
+            ElsabroService.getInstance().tasks.collectLatest { tasks ->
+                val running = tasks.filter { it.status == "running" }
+                if (running.isNotEmpty()) {
+                    val task = running.first()
+                    currentText = "ELSABRO: ${task.name} (${task.progress}%)"
+                    currentTooltip = "Running: ${task.name}"
+                    statusBar?.updateWidget(ID())
+                }
+            }
+        }
+    }
+
+    private fun updateState(state: ConnectionState) {
+        when (state) {
+            is ConnectionState.Connected -> {
+                currentText = "ELSABRO: Connected"
+                currentTooltip = "Click to open ELSABRO panel"
+            }
+            is ConnectionState.Connecting -> {
+                currentText = "ELSABRO: Connecting..."
+                currentTooltip = "Connecting to server"
+            }
+            is ConnectionState.Disconnected -> {
+                currentText = "ELSABRO: Disconnected"
+                currentTooltip = "Click to connect"
+            }
+            is ConnectionState.Error -> {
+                currentText = "ELSABRO: Error"
+                currentTooltip = "Error: ${state.message}"
+            }
+        }
+        statusBar?.updateWidget(ID())
+    }
+
+    override fun ID(): String = "ElsabroStatusBar"
+
+    override fun getPresentation(): StatusBarWidget.WidgetPresentation = this
+
+    override fun install(statusBar: StatusBar) {
+        this.statusBar = statusBar
+    }
+
+    override fun dispose() {
+        scope.cancel()
+    }
+
+    // TextPresentation implementation
+    override fun getText(): String = currentText
+
+    override fun getAlignment(): Float = Component.CENTER_ALIGNMENT
+
+    override fun getTooltipText(): String = currentTooltip
+
+    override fun getClickConsumer(): Consumer<MouseEvent> = Consumer {
+        // Open ELSABRO tool window or connect
+        val service = ElsabroService.getInstance()
+        if (service.connectionState.value is ConnectionState.Disconnected) {
+            service.connect()
+        } else {
+            // Open tool window
+            com.intellij.openapi.wm.ToolWindowManager
+                .getInstance(project)
+                .getToolWindow("ELSABRO")
+                ?.show()
+        }
+    }
+}
+```
+
+---
+
+## 8. KeybindingManager
+
+### 8.1 Default Keybindings
+
+```
++------------------------------------------------------------------+
+|                    ELSABRO Default Keybindings                    |
++------------------------------------------------------------------+
+|                                                                    |
+|  ACTION                    | VSCODE           | JETBRAINS         |
+|  --------------------------|------------------|-------------------|
+|  Run Agent                 | Ctrl+Shift+E R   | Ctrl+Shift+E R    |
+|  Pause Agent               | Ctrl+Shift+E P   | Ctrl+Shift+E P    |
+|  Cancel Task               | Ctrl+Shift+E C   | Ctrl+Shift+E C    |
+|  Show Panel                | Ctrl+Shift+E E   | Ctrl+Shift+E E    |
+|  Generate Tests            | Ctrl+Shift+E T   | Ctrl+Shift+E T    |
+|  Generate Docs             | Ctrl+Shift+E D   | Ctrl+Shift+E D    |
+|  AI Refactor               | Ctrl+Shift+E F   | Ctrl+Shift+E F    |
+|  Quick Actions             | Ctrl+Shift+E A   | Ctrl+Shift+E A    |
+|  Toggle Annotations        | Ctrl+Shift+E N   | Ctrl+Shift+E N    |
+|  Focus Agents View         | Ctrl+Shift+E 1   | Ctrl+Shift+E 1    |
+|  Focus Tasks View          | Ctrl+Shift+E 2   | Ctrl+Shift+E 2    |
+|  Focus Logs View           | Ctrl+Shift+E 3   | Ctrl+Shift+E 3    |
+|                                                                    |
+|  Note: On macOS, use Cmd instead of Ctrl                          |
++------------------------------------------------------------------+
+```
+
+### 8.2 Keybinding Manager (VSCode)
+
+```typescript
+// src/services/keybindingManager.ts
+import * as vscode from 'vscode';
+
+interface KeybindingConfig {
+  command: string;
+  key: string;
+  mac?: string;
+  when?: string;
+}
+
+export class KeybindingManager {
+  private static readonly DEFAULT_KEYBINDINGS: KeybindingConfig[] = [
+    {
+      command: 'elsabro.runAgent',
+      key: 'ctrl+shift+e r',
+      mac: 'cmd+shift+e r',
+      when: 'editorTextFocus',
+    },
+    {
+      command: 'elsabro.pauseAgent',
+      key: 'ctrl+shift+e p',
+      mac: 'cmd+shift+e p',
+    },
+    {
+      command: 'elsabro.cancelTask',
+      key: 'ctrl+shift+e c',
+      mac: 'cmd+shift+e c',
+    },
+    {
+      command: 'elsabro.showPanel',
+      key: 'ctrl+shift+e e',
+      mac: 'cmd+shift+e e',
+    },
+    {
+      command: 'elsabro.generateTests',
+      key: 'ctrl+shift+e t',
+      mac: 'cmd+shift+e t',
+      when: 'editorTextFocus',
+    },
+    {
+      command: 'elsabro.generateDocs',
+      key: 'ctrl+shift+e d',
+      mac: 'cmd+shift+e d',
+      when: 'editorTextFocus',
+    },
+    {
+      command: 'elsabro.refactor',
+      key: 'ctrl+shift+e f',
+      mac: 'cmd+shift+e f',
+      when: 'editorTextFocus && editorHasSelection',
+    },
+    {
+      command: 'elsabro.quickActions',
+      key: 'ctrl+shift+e a',
+      mac: 'cmd+shift+e a',
+      when: 'editorTextFocus',
+    },
+    {
+      command: 'elsabro.toggleAnnotations',
+      key: 'ctrl+shift+e n',
+      mac: 'cmd+shift+e n',
+    },
+    {
+      command: 'elsabro.focusAgentsView',
+      key: 'ctrl+shift+e 1',
+      mac: 'cmd+shift+e 1',
+    },
+    {
+      command: 'elsabro.focusTasksView',
+      key: 'ctrl+shift+e 2',
+      mac: 'cmd+shift+e 2',
+    },
+    {
+      command: 'elsabro.focusLogsView',
+      key: 'ctrl+shift+e 3',
+      mac: 'cmd+shift+e 3',
+    },
+  ];
+
+  private customKeybindings: Map<string, KeybindingConfig> = new Map();
+
+  constructor(private context: vscode.ExtensionContext) {
+    this.loadCustomKeybindings();
+  }
+
+  private loadCustomKeybindings(): void {
+    const config = vscode.workspace.getConfiguration('elsabro');
+    const custom = config.get<Record<string, string>>('keybindings') || {};
+
+    Object.entries(custom).forEach(([command, key]) => {
+      this.customKeybindings.set(command, {
+        command: `elsabro.${command}`,
+        key,
+      });
+    });
+  }
+
+  public getKeybinding(command: string): string | undefined {
+    // Check custom first
+    const custom = this.customKeybindings.get(command);
+    if (custom) {
+      return custom.key;
+    }
+
+    // Fall back to default
+    const defaultBinding = KeybindingManager.DEFAULT_KEYBINDINGS.find(
+      (kb) => kb.command === `elsabro.${command}`
+    );
+
+    if (defaultBinding) {
+      return process.platform === 'darwin'
+        ? defaultBinding.mac || defaultBinding.key
+        : defaultBinding.key;
+    }
+
+    return undefined;
+  }
+
+  public async setCustomKeybinding(command: string, key: string): Promise<void> {
+    const config = vscode.workspace.getConfiguration('elsabro');
+    const keybindings = config.get<Record<string, string>>('keybindings') || {};
+    keybindings[command] = key;
+
+    await config.update('keybindings', keybindings, vscode.ConfigurationTarget.Global);
+    this.customKeybindings.set(command, { command: `elsabro.${command}`, key });
+  }
+
+  public async resetKeybindings(): Promise<void> {
+    const config = vscode.workspace.getConfiguration('elsabro');
+    await config.update('keybindings', undefined, vscode.ConfigurationTarget.Global);
+    this.customKeybindings.clear();
+  }
+
+  public getDefaultKeybindings(): KeybindingConfig[] {
+    return KeybindingManager.DEFAULT_KEYBINDINGS;
+  }
+
+  public showKeybindingsQuickPick(): void {
+    const items = KeybindingManager.DEFAULT_KEYBINDINGS.map((kb) => ({
+      label: kb.command.replace('elsabro.', ''),
+      description: this.getKeybinding(kb.command.replace('elsabro.', '')),
+      detail: `When: ${kb.when || 'always'}`,
+      command: kb.command,
+    }));
+
+    vscode.window.showQuickPick(items, {
+      placeHolder: 'ELSABRO Keybindings',
+    }).then((selected) => {
+      if (selected) {
+        this.promptForNewKeybinding(selected.command);
+      }
+    });
+  }
+
+  private async promptForNewKeybinding(command: string): Promise<void> {
+    const input = await vscode.window.showInputBox({
+      prompt: `Enter new keybinding for ${command}`,
+      placeHolder: 'e.g., ctrl+shift+k',
+    });
+
+    if (input) {
+      await this.setCustomKeybinding(command.replace('elsabro.', ''), input);
+      vscode.window.showInformationMessage(
+        `Keybinding updated. Reload to apply changes.`
+      );
+    }
+  }
+}
+```
+
+---
+
+## 9. CLI Commands
+
+### 9.1 /elsabro:ide Commands
+
+```
++------------------------------------------------------------------+
+|                    /elsabro:ide CLI Commands                      |
++------------------------------------------------------------------+
+
+USAGE: /elsabro:ide <command> [options]
+
+COMMANDS:
+
+  install [ide]       Install ELSABRO extension/plugin
+                      Options:
+                        --ide=vscode|jetbrains|all (default: all)
+                        --version=<version> (default: latest)
+                        --channel=stable|beta|nightly (default: stable)
+
+  configure           Configure IDE integration
+                      Options:
+                        --server=<url> (WebSocket server URL)
+                        --auto-connect (enable auto-connect)
+                        --annotations (enable inline annotations)
+                        --codelens (enable CodeLens)
+
+  shortcuts           Manage keyboard shortcuts
+                      Options:
+                        --list (show all shortcuts)
+                        --reset (reset to defaults)
+                        --export=<file> (export to file)
+                        --import=<file> (import from file)
+
+  sync                Sync settings across IDEs
+                      Options:
+                        --push (push local settings)
+                        --pull (pull remote settings)
+                        --diff (show differences)
+
+  status              Show integration status
+                      Options:
+                        --verbose (detailed output)
+
+  uninstall [ide]     Remove ELSABRO extension/plugin
+
+EXAMPLES:
+
+  # Install for all IDEs
+  /elsabro:ide install
+
+  # Install only VSCode extension
+  /elsabro:ide install --ide=vscode
+
+  # Configure server URL
+  /elsabro:ide configure --server=ws://localhost:3847
+
+  # List all shortcuts
+  /elsabro:ide shortcuts --list
+
+  # Sync settings
+  /elsabro:ide sync --push
+```
+
+### 9.2 CLI Implementation
+
+```typescript
+// cli/commands/ide.ts
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+interface IDEConfig {
+  vscode: {
+    extensionPath: string;
+    settingsPath: string;
+  };
+  jetbrains: {
+    pluginPath: string;
+    settingsPath: string;
+  };
+}
+
+const IDE_CONFIG: IDEConfig = {
+  vscode: {
+    extensionPath: path.join(os.homedir(), '.vscode', 'extensions'),
+    settingsPath: path.join(os.homedir(), '.vscode', 'settings.json'),
+  },
+  jetbrains: {
+    pluginPath: path.join(os.homedir(), '.config', 'JetBrains'),
+    settingsPath: path.join(os.homedir(), '.config', 'JetBrains', 'elsabro.json'),
+  },
+};
+
+export function createIDECommand(): Command {
+  const ide = new Command('ide')
+    .description('Manage IDE integrations');
+
+  // Install command
+  ide
+    .command('install')
+    .description('Install ELSABRO extension/plugin')
+    .option('--ide <type>', 'IDE type (vscode|jetbrains|all)', 'all')
+    .option('--version <version>', 'Version to install', 'latest')
+    .option('--channel <channel>', 'Release channel', 'stable')
+    .action(async (options) => {
+      console.log(`Installing ELSABRO for ${options.ide}...`);
+
+      if (options.ide === 'all' || options.ide === 'vscode') {
+        await installVSCodeExtension(options.version, options.channel);
+      }
+
+      if (options.ide === 'all' || options.ide === 'jetbrains') {
+        await installJetBrainsPlugin(options.version, options.channel);
+      }
+
+      console.log('Installation complete!');
+    });
+
+  // Configure command
+  ide
+    .command('configure')
+    .description('Configure IDE integration')
+    .option('--server <url>', 'WebSocket server URL')
+    .option('--auto-connect', 'Enable auto-connect')
+    .option('--annotations', 'Enable inline annotations')
+    .option('--codelens', 'Enable CodeLens')
+    .action(async (options) => {
+      const config: any = {};
+
+      if (options.server) config['elsabro.serverUrl'] = options.server;
+      if (options.autoConnect) config['elsabro.autoConnect'] = true;
+      if (options.annotations) config['elsabro.showInlineAnnotations'] = true;
+      if (options.codelens) config['elsabro.enableCodeLens'] = true;
+
+      await updateVSCodeSettings(config);
+      await updateJetBrainsSettings(config);
+
+      console.log('Configuration updated!');
+    });
+
+  // Shortcuts command
+  ide
+    .command('shortcuts')
+    .description('Manage keyboard shortcuts')
+    .option('--list', 'Show all shortcuts')
+    .option('--reset', 'Reset to defaults')
+    .option('--export <file>', 'Export to file')
+    .option('--import <file>', 'Import from file')
+    .action(async (options) => {
+      if (options.list) {
+        listShortcuts();
+      } else if (options.reset) {
+        await resetShortcuts();
+        console.log('Shortcuts reset to defaults');
+      } else if (options.export) {
+        await exportShortcuts(options.export);
+        console.log(`Shortcuts exported to ${options.export}`);
+      } else if (options.import) {
+        await importShortcuts(options.import);
+        console.log(`Shortcuts imported from ${options.import}`);
+      }
+    });
+
+  // Sync command
+  ide
+    .command('sync')
+    .description('Sync settings across IDEs')
+    .option('--push', 'Push local settings')
+    .option('--pull', 'Pull remote settings')
+    .option('--diff', 'Show differences')
+    .action(async (options) => {
+      if (options.push) {
+        await syncPush();
+        console.log('Settings pushed to cloud');
+      } else if (options.pull) {
+        await syncPull();
+        console.log('Settings pulled from cloud');
+      } else if (options.diff) {
+        const diff = await syncDiff();
+        console.log('Settings differences:');
+        console.log(JSON.stringify(diff, null, 2));
+      }
+    });
+
+  // Status command
+  ide
+    .command('status')
+    .description('Show integration status')
+    .option('--verbose', 'Detailed output')
+    .action(async (options) => {
+      const status = await getIntegrationStatus();
+
+      console.log('\nELSABRO IDE Integration Status\n');
+      console.log('VSCode Extension:', status.vscode.installed ? 'Installed' : 'Not installed');
+      if (status.vscode.installed) {
+        console.log('  Version:', status.vscode.version);
+        console.log('  Connected:', status.vscode.connected ? 'Yes' : 'No');
+      }
+
+      console.log('\nJetBrains Plugin:', status.jetbrains.installed ? 'Installed' : 'Not installed');
+      if (status.jetbrains.installed) {
+        console.log('  Version:', status.jetbrains.version);
+        console.log('  Connected:', status.jetbrains.connected ? 'Yes' : 'No');
+      }
+
+      if (options.verbose) {
+        console.log('\nDetailed configuration:');
+        console.log(JSON.stringify(status, null, 2));
+      }
+    });
+
+  // Uninstall command
+  ide
+    .command('uninstall')
+    .description('Remove ELSABRO extension/plugin')
+    .argument('[ide]', 'IDE type', 'all')
+    .action(async (ide) => {
+      if (ide === 'all' || ide === 'vscode') {
+        await uninstallVSCodeExtension();
+        console.log('VSCode extension uninstalled');
+      }
+
+      if (ide === 'all' || ide === 'jetbrains') {
+        await uninstallJetBrainsPlugin();
+        console.log('JetBrains plugin uninstalled');
+      }
+    });
+
+  return ide;
+}
+
+// Helper functions
+async function installVSCodeExtension(version: string, channel: string): Promise<void> {
+  const extensionId = channel === 'stable'
+    ? 'elsabro.elsabro-vscode'
+    : `elsabro.elsabro-vscode-${channel}`;
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('code', ['--install-extension', extensionId], {
+      stdio: 'inherit',
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Installation failed with code ${code}`));
+    });
+  });
+}
+
+async function installJetBrainsPlugin(version: string, channel: string): Promise<void> {
+  // JetBrains plugin installation logic
+  console.log('Please install ELSABRO plugin from JetBrains Marketplace');
+  console.log('Search for "ELSABRO AI Orchestration" in your IDE plugins');
+}
+
+async function updateVSCodeSettings(config: Record<string, any>): Promise<void> {
+  const settingsPath = IDE_CONFIG.vscode.settingsPath;
+  let settings: Record<string, any> = {};
+
+  if (fs.existsSync(settingsPath)) {
+    const content = fs.readFileSync(settingsPath, 'utf-8');
+    settings = JSON.parse(content);
+  }
+
+  Object.assign(settings, config);
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+async function updateJetBrainsSettings(config: Record<string, any>): Promise<void> {
+  const settingsPath = IDE_CONFIG.jetbrains.settingsPath;
+  const dir = path.dirname(settingsPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(config, null, 2));
+}
+
+function listShortcuts(): void {
+  console.log('\nELSABRO Keyboard Shortcuts\n');
+  console.log('Action                    VSCode              JetBrains');
+  console.log('----------------------------------------------------------------');
+  console.log('Run Agent                 Ctrl+Shift+E R      Ctrl+Shift+E R');
+  console.log('Pause Agent               Ctrl+Shift+E P      Ctrl+Shift+E P');
+  console.log('Cancel Task               Ctrl+Shift+E C      Ctrl+Shift+E C');
+  console.log('Show Panel                Ctrl+Shift+E E      Ctrl+Shift+E E');
+  console.log('Generate Tests            Ctrl+Shift+E T      Ctrl+Shift+E T');
+  console.log('Generate Docs             Ctrl+Shift+E D      Ctrl+Shift+E D');
+  console.log('AI Refactor               Ctrl+Shift+E F      Ctrl+Shift+E F');
+  console.log('Quick Actions             Ctrl+Shift+E A      Ctrl+Shift+E A');
+  console.log('\nNote: On macOS, use Cmd instead of Ctrl');
+}
+
+async function resetShortcuts(): Promise<void> {
+  // Reset shortcuts implementation
+}
+
+async function exportShortcuts(file: string): Promise<void> {
+  // Export shortcuts implementation
+}
+
+async function importShortcuts(file: string): Promise<void> {
+  // Import shortcuts implementation
+}
+
+async function syncPush(): Promise<void> {
+  // Sync push implementation
+}
+
+async function syncPull(): Promise<void> {
+  // Sync pull implementation
+}
+
+async function syncDiff(): Promise<any> {
+  // Sync diff implementation
+  return {};
+}
+
+async function getIntegrationStatus(): Promise<any> {
+  return {
+    vscode: {
+      installed: true,
+      version: '3.7.0',
+      connected: false,
+    },
+    jetbrains: {
+      installed: false,
+      version: null,
+      connected: false,
+    },
+  };
+}
+
+async function uninstallVSCodeExtension(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('code', ['--uninstall-extension', 'elsabro.elsabro-vscode'], {
+      stdio: 'inherit',
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Uninstallation failed with code ${code}`));
+    });
+  });
+}
+
+async function uninstallJetBrainsPlugin(): Promise<void> {
+  // JetBrains plugin uninstallation logic
+}
+```
+
+---
+
+## Diagrams de Arquitectura
+
+### Flujo de Comunicacion
+
+```
++------------------------------------------------------------------+
+|                  Communication Flow Diagram                       |
++------------------------------------------------------------------+
+
+                          +------------------+
+                          |    Developer     |
+                          +--------+---------+
+                                   |
+                    +--------------+--------------+
+                    |                             |
+            +-------v-------+             +-------v-------+
+            |    VSCode     |             |   JetBrains   |
+            |   Extension   |             |    Plugin     |
+            +-------+-------+             +-------+-------+
+                    |                             |
+                    |     +----------------+      |
+                    +---->|   LSP Server   |<-----+
+                          | (Optional Hub) |
+                          +-------+--------+
+                                  |
+                          +-------v--------+
+                          | WebSocket Conn |
+                          +-------+--------+
+                                  |
+                          +-------v--------+
+                          | ELSABRO Server |
+                          +-------+--------+
+                                  |
+            +---------------------+---------------------+
+            |                     |                     |
+    +-------v-------+     +-------v-------+     +-------v-------+
+    |    Agents     |     |    Tasks      |     |     Logs      |
+    +---------------+     +---------------+     +---------------+
+```
+
+### Estado de Sesion
+
+```
++------------------------------------------------------------------+
+|                     Session State Machine                         |
++------------------------------------------------------------------+
+
+    +-------------+
+    | DISCONNECTED|<-----------+
+    +------+------+            |
+           |                   |
+           | connect()         | disconnect() / error
+           v                   |
+    +------+------+            |
+    |  CONNECTING |------------+
+    +------+------+
+           |
+           | connected
+           v
+    +------+------+
+    |  CONNECTED  |<-----------+
+    +------+------+            |
+           |                   |
+           | runAgent()        | taskComplete()
+           v                   |
+    +------+------+            |
+    |   RUNNING   |------------+
+    +------+------+
+           |
+           | pause()
+           v
+    +------+------+
+    |   PAUSED    |
+    +-------------+
+           |
+           | resume() / cancel()
+           v
+      (back to CONNECTED or RUNNING)
+```
+
+---
+
+## Changelog
+
+| Version | Fecha | Cambios |
+|---------|-------|---------|
+| 3.7.0 | 2025-02 | Initial IDE integrations release |
+| 3.6.0 | 2025-01 | Core agent improvements |
+| 3.5.0 | 2024-12 | WebSocket protocol updates |
+
+---
+
+## Referencias
+
+- [VSCode Extension API](https://code.visualstudio.com/api)
+- [IntelliJ Platform SDK](https://plugins.jetbrains.com/docs/intellij/)
+- [Language Server Protocol](https://microsoft.github.io/language-server-protocol/)
+- [ELSABRO Core Documentation](/references/core-api.md)