@mrtrinhvn/ag-kit 1.1.9 → 1.3.1

package/template/.agent/skills/telegram-agentic-gateway/templates/CdpService.ts.template

@@ -0,0 +1,514 @@
+import WebSocket from 'ws';
+import * as http from 'http';
+import * as fs from 'fs';
+
+import { config } from '../config/env.js';
+import { EventEmitter } from 'events';
+
+const SELECTORS = {
+  CHAT_INPUT: 'div[role="textbox"][aria-label="Chat input"], div[role="textbox"]:not(.xterm-helper-textarea)',
+};
+
+export class CdpService extends EventEmitter {
+  private ws: WebSocket | null = null;
+  private connected = false;
+  private contexts: { id: number; name: string; url: string }[] = [];
+  private pendingCalls = new Map<number, { resolve: Function; reject: Function; timer: NodeJS.Timeout }>();
+  private idCounter = 1;
+  private callTimeout = 30000;
+
+  // ─── Discovery ──────────────────────────────────────────────────────
+  private async getJson(url: string): Promise<any[]> {
+    return new Promise((resolve, reject) => {
+      const req = http.get(url, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => { try { resolve(JSON.parse(data)); } catch (e) { reject(e); } });
+      });
+      req.on('error', reject);
+      req.setTimeout(3000, () => { req.destroy(); reject(new Error('Timeout')); });
+    });
+  }
+
+  async discoverTarget(): Promise<string> {
+    const port = config.idePort;
+
+    // We trust the port defined in .env (updated by port_utils.sh)
+    try {
+      const pages = await this.getJson(`http://127.0.0.1:${port}/json/list`);
+      // Filter by project name if specified
+      const projectMatch = (p: any) => {
+        if (!config.projectName) return true;
+        const title = (p.title || '').toLowerCase();
+        const url = (p.url || '').toLowerCase();
+        const lowName = config.projectName.toLowerCase();
+        return title.includes(lowName) || url.includes(lowName);
+      };
+
+      const sortedPages = pages.sort((a, b) => {
+        const aUrl = (a.url || '').toLowerCase();
+        const bUrl = (b.url || '').toLowerCase();
+        const isAWorkbench = aUrl.includes('workbench.html');
+        const isBWorkbench = bUrl.includes('workbench.html');
+        if (isAWorkbench && !isBWorkbench) return -1;
+        if (!isAWorkbench && isBWorkbench) return 1;
+        return 0;
+      });
+
+      const target = sortedPages.find((p: any) =>
+        p.webSocketDebuggerUrl &&
+        (p.url?.includes('workbench') || p.title?.includes('Antigravity') || p.title?.includes('Code')) &&
+        projectMatch(p)
+      );
+      if (target) {
+        console.log(`[CDP] 🔍 Found IDE for "${config.projectName}" on port ${port}: "${target.title}"`);
+        return target.webSocketDebuggerUrl;
+      }
+    } catch { /* connection failed */ }
+    throw new Error(`No IDE found for project "${config.projectName}" on port ${port}. Please run ./start.sh to sync.`);
+  }
+
+  // ─── Connection ─────────────────────────────────────────────────────
+  async connect(): Promise<void> {
+    const wsUrl = await this.discoverTarget();
+    this.ws = new WebSocket(wsUrl);
+
+    await new Promise<void>((resolve, reject) => {
+      this.ws!.on('open', () => { this.connected = true; resolve(); });
+      this.ws!.on('error', reject);
+    });
+
+    this.ws.on('message', (msg: WebSocket.Data) => {
+      try {
+        const data = JSON.parse(msg.toString());
+        // Handle pending call responses
+        if (data.id !== undefined && this.pendingCalls.has(data.id)) {
+          const { resolve, reject, timer } = this.pendingCalls.get(data.id)!;
+          clearTimeout(timer);
+          this.pendingCalls.delete(data.id);
+          if (data.error) reject(new Error(data.error.message)); else resolve(data.result);
+        }
+        // Track execution contexts
+        if (data.method === 'Runtime.executionContextCreated') {
+          this.contexts.push(data.params.context);
+        }
+        if (data.method === 'Runtime.executionContextDestroyed') {
+          this.contexts = this.contexts.filter(c => c.id !== data.params.executionContextId);
+        }
+      } catch { /* ignore parse error */ }
+    });
+
+    this.ws.on('close', () => {
+      this.connected = false;
+      this.ws = null;
+      console.log('[CDP] ⚡ Disconnected from IDE');
+      this.emit('disconnected');
+    });
+
+    // Get execution contexts
+    await this.call('Runtime.enable', {});
+    console.log('[CDP] ✅ Connected to IDE');
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.ws) { this.ws.close(); this.ws = null; }
+    this.connected = false;
+    this.contexts = [];
+  }
+
+  getContexts(): { id: number; name: string; url: string }[] { return this.contexts; }
+
+  isConnected(): boolean { return this.connected; }
+
+  // ─── CDP Call ────────────────────────────────────────────────────────
+  async call(method: string, params: any = {}): Promise<any> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('CDP not connected');
+    }
+    return new Promise((resolve, reject) => {
+      const id = this.idCounter++;
+      const timer = setTimeout(() => {
+        this.pendingCalls.delete(id);
+        reject(new Error(`Timeout: ${method}`));
+      }, this.callTimeout);
+      this.pendingCalls.set(id, { resolve, reject, timer });
+      this.ws!.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  /**
+   * Evaluate a script on any available execution context (e.g. child webviews)
+   */
+  async evaluateOnAnyContext(expression: string): Promise<any> {
+    for (const ctx of this.contexts) {
+      try {
+        const res = await this.call('Runtime.evaluate', {
+          expression, returnByValue: true, contextId: ctx.id,
+        });
+        if (res?.result?.value !== undefined && res.result.value !== null) {
+          return res.result.value;
+        }
+      } catch { /* next context */ }
+    }
+    return null;
+  }
+
+  // ─── Prompt Injection ───────────────────────────────────────────────
+  async injectPrompt(text: string): Promise<boolean> {
+    // 1. Focus chat input
+    const focused = await this.focusChatInput();
+    if (!focused) throw new Error('Cannot find chat input in IDE');
+
+    // 2. Clear existing text (Ctrl+A → Backspace)
+    await this.clearInput();
+
+    // 3. Type the prompt
+    await this.call('Input.insertText', { text });
+    await this.sleep(100);
+
+    // 4. Press Enter to submit
+    await this.pressEnter();
+    console.log(`[CDP] 📨 Injected prompt (${text.length} chars)`);
+    return true;
+  }
+
+  private async focusChatInput(): Promise<boolean> {
+    const script = `(() => {
+      const editors = Array.from(document.querySelectorAll('${SELECTORS.CHAT_INPUT}'));
+      const visible = editors.filter(el => el.offsetParent !== null);
+      const editor = visible[visible.length - 1];
+      if (!editor) return false;
+      editor.focus();
+      return true;
+    })()`;
+
+    for (const ctx of this.contexts) {
+      try {
+        const res = await this.call('Runtime.evaluate', {
+          expression: script, returnByValue: true, contextId: ctx.id,
+        });
+        if (res?.result?.value === true) return true;
+      } catch { /* next context */ }
+    }
+    return false;
+  }
+
+  private async clearInput(): Promise<void> {
+    const mod = process.platform === 'darwin' ? 4 : 2; // Meta / Ctrl
+    await this.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'a', code: 'KeyA', modifiers: mod, windowsVirtualKeyCode: 65 });
+    await this.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'a', code: 'KeyA', modifiers: mod, windowsVirtualKeyCode: 65 });
+    await this.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 });
+    await this.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 });
+    await this.sleep(50);
+  }
+
+  private async pressEnter(): Promise<void> {
+    await this.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 });
+    await this.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 });
+  }
+
+  // ─── Response Extraction ────────────────────────────────────────────
+  async extractLastResponse(): Promise<string> {
+    // 1. NEURAL ECHO FAST-TRACK (Highest priority if Agent actively dictates response)
+    try {
+      if (fs.existsSync('.last_response.json')) {
+        const lastResp = JSON.parse(fs.readFileSync('.last_response.json', 'utf8'));
+        if (Date.now() - new Date(lastResp.timestamp).getTime() < 120000) {
+          return lastResp.text;
+        }
+      }
+    } catch (e) { }
+
+    // 2. DOM EXTRACTION FALLBACK (Precise evaluation across contexts)
+    const script = `(() => {
+      function queryAllShadows(selector, root = document) {
+        let results = [];
+        if (root.querySelectorAll) results.push(...root.querySelectorAll(selector));
+        let walker = document.createTreeWalker(root, 1, null, false);
+        while (walker.nextNode()) {
+          if (walker.currentNode.shadowRoot) {
+            results.push(...queryAllShadows(selector, walker.currentNode.shadowRoot));
+          }
+        }
+        return results;
+      }
+
+      // Find all assistant responses (often rendered in markdown-body or generic message containers)
+      const containers = queryAllShadows('.markdown-body, [class*="message-container"], [class*="chat-message"], .select-text');
+      
+      const assistantMsgs = containers.filter(el => {
+        if (!el || !el.classList) return false;
+        
+        // Skip elements that are visually hidden (like collapsed thought blocks)
+        let curr = el;
+        while(curr) {
+          if (curr.classList && (curr.classList.contains('opacity-0') || curr.classList.contains('max-h-0'))) return false;
+          curr = curr.parentNode || curr.host;
+        }
+
+        // Exclude the outer application shell to avoid grabbing the input box or header
+        if (el.classList.contains('chat-app') || el.id === 'chat-container' || ['main', 'body'].includes(el.tagName?.toLowerCase())) return false;
+
+        const html = el.innerHTML.toLowerCase();
+        // Skip user messages and UI elements
+        if (html.includes('assistant') || html.includes('bot') || html.includes('response') || el.classList.contains('markdown-body') || el.classList.contains('markdown') || el.classList.contains('select-text')) {
+           return true;
+        }
+        return false;
+      });
+
+      function cleanTextNode(node) {
+        const clone = node.cloneNode(true);
+        // Remove <details> and <summary> which contain thoughts
+        const details = clone.querySelectorAll('details, summary, .thought, .thought-block, style, script');
+        details.forEach(d => d.remove());
+        
+        // Remove known UI artifacts and collapsed thought blocks
+        const uis = clone.querySelectorAll('.ask-anything, .model-selector, [class*="placeholder"], [class*="status"], .opacity-0, .max-h-0, [class*="max-h-0"]');
+        uis.forEach(u => u.remove());
+        
+        let text = (clone.innerText || clone.textContent || '').trim();
+        
+        // Clean up leaked agent state headers and thought phase tags that slip through
+        text = text.replace(/🧠\\s*(CEO Orchestrator|Antigravity|Agent|Thought):?/gi, '');
+        text = text.replace(/⚡\\s*Planning/gi, '');
+        text = text.replace(/\\d+\\s+files?\\s+with\\s+changes/gi, '');
+        text = text.replace(/Prioritizing Tool Specificity[\\s\\S]*?before proceeding\\./gi, '');
+        text = text.replace(/^(Đang xử lý|Generating|Thinking|Running).*$/gim, '');
+        
+        return text.trim();
+      }
+
+      if (assistantMsgs.length > 0) {
+        return cleanTextNode(assistantMsgs[assistantMsgs.length - 1]);
+      }
+
+      // Secondary fallback if specific assistant wrappers aren't matched
+      const allMsgs = queryAllShadows('[class*="message"], [class*="chat"]');
+      const filteredMsgs = allMsgs.filter(el => {
+        if (!el || !el.classList) return false;
+        return !el.classList.contains('chat-app') && el.id !== 'chat-container';
+      });
+      if (filteredMsgs.length > 0) {
+        return cleanTextNode(filteredMsgs[filteredMsgs.length - 1]);
+      }
+
+      return '';
+    })()`;
+
+    for (let i = this.contexts.length - 1; i >= 0; i--) {
+      const ctx = this.contexts[i];
+      try {
+        const res = await this.call('Runtime.evaluate', {
+          expression: script, returnByValue: true, contextId: ctx.id,
+        });
+        if (res?.result?.value) {
+          let text = res.result.value.trim();
+          // Filter out obvious whole-UI dumps if they accidentally catch the header
+          if (!text.includes('Explored') && text.length > 10) {
+             return text;
+          }
+        }
+      } catch { /* ignore context error */ }
+    }
+
+    // 3. NATIVE AXTREE EXTRACTION (Absolute last resort, heavily stripped)
+    try {
+      const tree = await this.call('Accessibility.getFullAXTree');
+      const nodes = tree?.nodes || [];
+      const textNodes = nodes.filter((n: any) => 
+          ['StaticText', 'InlineTextBox', 'paragraph'].includes(n.role?.value) && n.name?.value?.trim()
+      ).map((n: any) => n.name.value.trim());
+
+      let promptIndex = -1;
+      for (let i = textNodes.length - 1; i >= 0; i--) {
+          if (/^\[TG-Topic-\d+\]/.test(textNodes[i])) {
+              promptIndex = i;
+              break;
+          }
+      }
+
+      if (promptIndex !== -1) {
+          let lines: string[] = [];
+          for (let i = promptIndex + 1; i < textNodes.length; i++) {
+              let txt = textNodes[i];
+              let txtLower = txt.toLowerCase();
+
+              if (/ask anything/i.test(txtLower)) break;
+              if (/@ to mention/i.test(txtLower)) break;
+              if (/\/ for workflows/i.test(txtLower)) break;
+              if (/search the workspace/i.test(txtLower)) break;
+              if (/^\[TG-Topic-\d+\]/i.test(txt)) break;
+
+              if (/press desired key combination/i.test(txtLower)) continue;
+              
+              // Skip Tool Events & Execution Status
+              const skipExactList = ['content_copy', 'always run', 'cancel', 'reject all', 'accept all', 'preview', 'edit', 'analyzed', 'generating..', 'planning'];
+              if (skipExactList.includes(txtLower.trim())) continue;
+              
+              if (/^\d+\s*files?\s*with\s*changes/i.test(txtLower)) continue;
+              if (/^[+-]\d+$/.test(txt.trim())) continue;
+              if (/(Gemini|Claude|GPT|Ollama).*?(Pro|High|Sonnet|Opus|Flash|Tool|Agent)/i.test(txt)) continue;
+              if (/(CEO Orchestrator|Thought for \d+s|Antigravity)/i.test(txt)) continue;
+              
+              // Skip Tool Usage strings (Explored X pages, Ran command, Edited X files, etc.)
+              if (/^(explored|ran command|ran background command|checked command status|edited|evaluating|analyzing|prioritizing|refining|formulating) /i.test(txtLower)) continue;
+              if (/^\d+\s+(file|command|search|page|browser)s?/i.test(txtLower)) continue;
+              if (txtLower === 'explored' || txtLower === 'exploring' || txtLower === 'ran command' || txtLower === 'exit code 0') continue;
+              if (txt === '🧠' || txt === '⚡' || txt.includes('🧠') || txt.includes('⚡')) continue;
+
+              if (txt.length > 1 && !lines.includes(txt)) {
+                  lines.push(txt);
+              }
+          }
+          if (lines.length > 0) return lines.join('\n');
+      }
+    } catch (e) { }
+
+    return '';
+  }
+
+  /**
+   * Extract the last user message from the IDE chat panel.
+   */
+  async extractLastUserMessage(): Promise<string> {
+    const script = `(() => {
+      function queryAllShadows(selector, root = document) {
+        let results = [];
+        if (root.querySelectorAll) results.push(...root.querySelectorAll(selector));
+        let walker = document.createTreeWalker(root, 1, null, false);
+        while (walker.nextNode()) {
+          if (walker.currentNode.shadowRoot) {
+            results.push(...queryAllShadows(selector, walker.currentNode.shadowRoot));
+          }
+        }
+        return results;
+      }
+
+      const containers = queryAllShadows('[class*="message-container"], [class*="chat-message"]');
+      const userMsgs = containers.filter(el => {
+        const html = el.innerHTML.toLowerCase();
+        return !html.includes('assistant') && !html.includes('response') && !html.includes('bot');
+      });
+      if (userMsgs.length === 0) return '';
+      const last = userMsgs[userMsgs.length - 1];
+      return last.innerText || last.textContent || '';
+    })()`;
+
+    for (const ctx of this.contexts) {
+      if (ctx.url && ctx.url.includes('workbench.html')) {
+        try {
+          const res = await this.call('Runtime.evaluate', {
+            expression: script, returnByValue: true, contextId: ctx.id,
+          });
+          if (res?.result?.value) return res.result.value.trim();
+        } catch { /* next context */ }
+      }
+    }
+    return '';
+  }
+
+  /**
+   * Check if AI is still generating (spinner/stop button present)
+   */
+  async isGenerating(): Promise<boolean> {
+    try {
+      const tree = await this.call('Accessibility.getFullAXTree');
+      const nodes = tree?.nodes || [];
+      
+      const isGen = nodes.some((n: any) => {
+        const role = n.role?.value;
+        const name = (n.name?.value || '').trim().toLowerCase();
+        if (!name) return false;
+        
+        // Check for Cancel/Stop button
+        if (role === 'button' && (name === 'cancel' || name.includes('stop generation') || name === 'stop')) return true;
+        
+        // Exact strings that indicate loading state in the UI (not user text)
+        const exactLoadingStates = [
+            'generating...', 'thinking...', 'analyzing...', 'working...', 
+            'evaluating...', 'planning...', 'running...', 'searching...'
+        ];
+        
+        if (role === 'StaticText' || role === 'InlineTextBox') {
+            if (exactLoadingStates.includes(name)) return true;
+            if (name.startsWith('running command:')) return true;
+        }
+        return false;
+      });
+      
+      if (isGen) return true;
+    } catch { /* ignore */ }
+    return false;
+  }
+
+  /**
+   * Extract the real-time agent status text (e.g. "Running command...", "Searching web...")
+   */
+  async extractAgentStatus(): Promise<string> {
+    try {
+      const tree = await this.call('Accessibility.getFullAXTree');
+      const nodes = tree?.nodes || [];
+      
+      for (const n of nodes) {
+        if (n.role?.value !== 'StaticText' && n.role?.value !== 'InlineTextBox') continue;
+        const text = n.name?.value?.trim() || '';
+        if (text.length > 3 && text.length < 150) {
+          const lower = text.toLowerCase();
+          
+          // Must exactly end with "..." to be a status indicator, or be a specific tool execution
+          if (lower.endsWith('...')) {
+              if (
+                  lower.startsWith('thought') ||
+                  lower.startsWith('thinking') || 
+                  lower.startsWith('running') || 
+                  lower.startsWith('analyzing') || 
+                  lower.startsWith('reading') ||
+                  lower.startsWith('viewing') ||
+                  lower.startsWith('searching') ||
+                  lower.startsWith('executing') ||
+                  lower.startsWith('writing') ||
+                  lower.startsWith('listing') ||
+                  lower.startsWith('generating') ||
+                  lower.startsWith('evaluating') ||
+                  lower.startsWith('exploring') ||
+                  lower.startsWith('considering') ||
+                  lower.startsWith('planning')
+              ) {
+                return text;
+              }
+          }
+          if (lower.match(/^\\d+\\s+files?\\s+with\\s+changes/i)) return text;
+          if (lower.startsWith('ran command') || lower.startsWith('explored')) return text;
+        }
+      }
+      
+      // Generic fallback
+      if (await this.isGenerating()) {
+        return 'Đang xử lý (Processing)...';
+      }
+    } catch { /* ignore */ }
+    
+    return '';
+  }
+
+  /**
+   * Capture a screenshot of the current page
+   */
+  async captureScreenshot(): Promise<Buffer | null> {
+    try {
+      const res = await this.call('Page.captureScreenshot', { format: 'png' });
+      if (res && res.data) {
+        return Buffer.from(res.data, 'base64');
+      }
+    } catch (err) {
+      console.error('[CDP] ❌ Screenshot failed:', err);
+    }
+    return null;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(r => setTimeout(r, ms));
+  }
+}
+

package/template/.agent/skills/telegram-agentic-gateway/templates/ResponseMonitor.ts.template

@@ -0,0 +1,102 @@
+import { CdpService } from './CdpService.js';
+
+export interface MonitorResult {
+  response: string;
+  completed: boolean;
+  error?: string;
+}
+
+export class ResponseMonitor {
+  private cdp: CdpService;
+  private pollIntervalMs = 2000;
+  private maxWaitMs = 86400000; // 24 hours (Infinite)
+
+  constructor(cdp: CdpService) {
+    this.cdp = cdp;
+  }
+
+  /**
+   * Wait for AI to finish generating and return the full response.
+   * Calls onProgress for each intermediate state.
+   * Calls onStatus for thinking/status updates.
+   */
+  async waitForResponse(
+    onProgress?: (partial: string) => void,
+    onStatus?: (status: string) => void
+  ): Promise<MonitorResult> {
+    const startTime = Date.now();
+    let lastResponse = '';
+    let staleCount = 0;
+    let statusUpdateCount = 0;
+
+    // Initial wait
+    let lastKnownStatus = 'Khởi tạo tác vụ... (Initializing)';
+    if (onStatus) onStatus(lastKnownStatus);
+    await this.sleep(1500);
+
+    while (Date.now() - startTime < this.maxWaitMs) {
+      const generating = await this.cdp.isGenerating();
+      const currentResponse = await this.cdp.extractLastResponse();
+
+      // Update status every cycle, the callback will debounce it
+      if (onStatus) {
+        const liveStatus = await this.cdp.extractAgentStatus();
+        if (liveStatus && !liveStatus.includes('Đang xử lý')) {
+           lastKnownStatus = liveStatus;
+        }
+        // Luôn gửi trạng thái sống động cuối cùng (VD: Thought for 3s, Running command...)
+        onStatus(lastKnownStatus);
+      }
+      statusUpdateCount++;
+
+      // Detect new content
+      if (currentResponse && currentResponse !== lastResponse) {
+        lastResponse = currentResponse;
+        staleCount = 0;
+        if (onProgress) onProgress(this.truncate(currentResponse, 4000));
+      } else {
+        staleCount++;
+      }
+
+      // AI finished: not generating + response stable for 3 polls
+      if (!generating && lastResponse && staleCount >= 2) {
+        return { response: lastResponse, completed: true };
+      }
+
+      // Timeout safety: if stuck generating but no new text for 60 polls (120 seconds)
+      if (generating && staleCount >= 60 && lastResponse && lastResponse.length > 20) {
+        return { response: lastResponse, completed: true };
+      }
+
+      // If NOT generating but stuck with some UI artifact that wouldn't parse well, timeout sooner
+      if (!generating && staleCount >= 10 && lastResponse) {
+        return { response: lastResponse, completed: true };
+      }
+
+      // If NOT generating and still NO response after 15 polls (30 seconds), it probably failed or returned empty
+      if (!generating && staleCount >= 15 && !lastResponse) {
+        return { 
+          response: "❌ Phản hồi đã hoàn tất nhưng bot không trích xuất được nội dung (Rỗng).", 
+          completed: true 
+        };
+      }
+
+      await this.sleep(this.pollIntervalMs);
+    }
+
+    return {
+      response: lastResponse || '⏰ Quá thời gian chờ (15 phút). Đặc vụ có thể đang chạy một quá trình quá tải hoặc IDE đã mất kết nối.',
+      completed: false,
+      error: 'Timeout waiting for IDE response',
+    };
+  }
+
+  private truncate(text: string, maxLen: number): string {
+    if (text.length <= maxLen) return text;
+    return text.substring(0, maxLen) + '\n\n... (truncated)';
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(r => setTimeout(r, ms));
+  }
+}

package/template/.agent/skills/telegram-agentic-gateway/templates/start.sh.template

@@ -0,0 +1,12 @@
+#!/bin/bash
+# 🏢 CEOgravity - Startup Orchestrator
+# Golden Combo Edition (V3)
+
+# 1. Load config
+if [ -f .env ]; then
+    source .env
+fi
+
+# 2. Khởi động Giao diện & Agent (Agent-Defined)
+echo "🚀 Activating CEOgravity Golden Portal..."
+bash .agent/scripts/receptionist_up.sh