mortgram-bridge 2.3.0 → 3.0.0

package/.env

@@ -0,0 +1,2 @@
+MORTGRAM_API_KEY=MG_LIVE_sk_0bb5705dd55555ae49ddbee6335ff83fef538f12399936ae
+MORTGRAM_API_URL=https://mortgram.online/api/ingest

package/index.mjs

@@ -16,17 +16,59 @@ import path from "node:path";
 import os from "node:os";
 import crypto from "node:crypto";
 
-// ─── CLI Args ─────────────────────────────────────────────────────
+// ─── CLI Args & Config ────────────────────────────────────────────
 const args = process.argv.slice(2);
 function getArg(name) {
     const idx = args.indexOf(`--${name}`);
     return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
 }
 
-const MORTGRAM_TOKEN = getArg("token") || process.env.MORTGRAM_API_KEY || process.env.MG_LIVE_KEY || "";
-const MORTGRAM_API = getArg("api") || process.env.MORTGRAM_API_URL || "https://mortgram.online/api/ingest";
+// 1. Attempt to load .env manually (since we might not have dotenv)
+function loadEnv() {
+    try {
+        const envPath = path.join(process.cwd(), "bridge", ".env");
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, "utf8");
+            const env = {};
+            for (const line of content.split("\n")) {
+                const match = line.match(/^([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    const val = match[2].trim().replace(/^["']|["']$/g, ""); // remove quotes
+                    env[key] = val;
+                }
+            }
+            return env;
+        }
+    } catch (e) { }
+    return {};
+}
+const localEnv = loadEnv();
+
+const MORTGRAM_TOKEN = getArg("token") || process.env.MORTGRAM_API_KEY || localEnv.MORTGRAM_API_KEY || process.env.MG_LIVE_KEY || "";
+const MORTGRAM_API = getArg("api") || process.env.MORTGRAM_API_URL || localEnv.MORTGRAM_API_URL || "https://mortgram.online/api/ingest";
 const GATEWAY_URL_OVERRIDE = getArg("gateway-url");
-const AGENT_ID = getArg("agent-id") || "gateway-bridge";
+
+// 2. Persistent Agent ID Logic
+// Priority: CLI > .env > Hardware ID
+function getStableId() {
+    // Try to find a stored ID in .env 
+    // (Note: we just read it above, but let's check for AGENT_ID specifically)
+    if (process.env.AGENT_ID) return process.env.AGENT_ID;
+    if (localEnv.AGENT_ID) return localEnv.AGENT_ID;
+
+    // Generate Hardware ID
+    try {
+        const idString = `${os.hostname()}-${os.platform()}-${os.arch()}-${os.cpus().length}`;
+        const hash = crypto.createHash("sha256").update(idString).digest("hex").substring(0, 12);
+        return `agent-${hash}`; // e.g. agent-3f4a9b...
+    } catch (e) {
+        return "unknown-agent-" + Math.floor(Math.random() * 10000);
+    }
+}
+
+const GLOBAL_AGENT_ID = getArg("agent-id") || getStableId();
+console.log(`\x1b[36m[MORTGRAM] 🆔 Agent Identity: ${GLOBAL_AGENT_ID}\x1b[0m`);
 
 if (!MORTGRAM_TOKEN) {
     console.error("\x1b[31m[MORTGRAM] ERROR: No --token provided.\x1b[0m");
@@ -72,13 +114,17 @@ let connected = false;
 let connectNonce = null;
 let reconnectDelay = 500;
 let eventCount = 0;
-let lastAgentId = AGENT_ID;
-let lastAgentName = "";
+// We no longer track dynamic agent IDs. We enforce GLOBAL_AGENT_ID.
+let lastAgentId = GLOBAL_AGENT_ID;
+let lastAgentName = "Founder-Main"; // 🔒 Hardcoded for production
+let lastSessionId = ""; // Track session ID for replays
 let heartbeatTimer = null;
+let costTimer = null; // New timer for cost updates
 
 // Tracking
 let latestThought = "Bridge starting...";
 let dailyCost = 0;
+let totalTokens = 0; // Accumulated token count from scraper
 let totalTurns = 0;
 let successfulTools = 0;
 
@@ -129,16 +175,17 @@ async function _sendPayload(payload, attempt = 0) {
 
 async function sendToMortgram(type, content, metadata = {}) {
     const payload = {
-        agent_id: lastAgentId,
+        agent_id: GLOBAL_AGENT_ID, // 🔒 ALWAYS use the stable ID
         type,
         content,
         metadata: {
             ...metadata,
-            agent_name: lastAgentName || lastAgentId,
+            agent_name: lastAgentName || GLOBAL_AGENT_ID,
             daily_cost: dailyCost,
             efficiency: totalTurns > 0 ? (successfulTools / totalTurns) : 0,
             latest_thought: latestThought,
             status: "online",
+            session_id: lastSessionId,
             timestamp: new Date().toISOString()
         }
     };
@@ -158,25 +205,45 @@ async function sendToMortgram(type, content, metadata = {}) {
     }
 }
 
+// ─── Event Processing ─────────────────────────────────────────────
 // ─── Event Processing ─────────────────────────────────────────────
 function processEvent(evt) {
     const { event, payload, seq } = evt;
 
-    // Skip internal/tick events
-    if (event === "tick" || event === "connect.challenge") return;
+    // ═══ FILTERING GATE ═══
+    // 1a. Protocol-level noise — always drop
+    if (event.startsWith("chat.")) return;
+    if (event.startsWith("connect.")) return;
+    if (event === "tick") return;
 
-    eventCount++;
-
-    // Extract agent info from various event shapes
+    // 1b. agentId Gate — ONLY forward events with an agent identity.
+    //     If the payload has no agentId, agent_id, runId, or sessionId,
+    //     it's gateway chatter (message IDs, chat IDs) → skip.
     const data = payload || {};
-    const agentId = data.agentId || data.agent_id || data.runId?.split("-")[0] || lastAgentId;
-    if (agentId !== lastAgentId && agentId !== "gateway-bridge") {
-        lastAgentId = agentId;
+    const hasAgentIdentity = !!(data.agentId || data.agent_id || data.runId || data.sessionId || evt.sessionId);
+
+    // Allow system-level events through even without agent ID
+    const isSystemEvent = event === "system.notify" || event === "system.presence" || event === "shutdown";
+    if (!hasAgentIdentity && !isSystemEvent) {
+        // Silent skip — this is a chat/message ID event with no agent context
+        return;
     }
-    // Extract agent name if available
-    const agentName = data.agentName || data.agent_name || data.displayName || data.name || "";
-    if (agentName && agentName !== lastAgentName) {
-        lastAgentName = agentName;
+
+    eventCount++;
+
+    // data already extracted above in agentId gate
+
+    // Extract agent name if available, just for metadata display
+    // const agentName = data.agentName || data.agent_name || data.displayName || data.name || "";
+    // if (agentName && agentName !== lastAgentName) {
+    //     lastAgentName = agentName;
+    // }
+    // 🔒 Production Override: Always "Primary Observer"
+
+    // Extract session ID (critical for replays)
+    const sessionId = data.sessionId || data.session_id || data.runId || evt.sessionId || "";
+    if (sessionId && sessionId !== lastSessionId) {
+        lastSessionId = sessionId;
     }
 
     let type = "log";
@@ -187,24 +254,53 @@ function processEvent(evt) {
         // Agent-level events
         if (event === "agent.run.start" || event === "agent.start") {
             type = "system";
-            content = `Agent session started: ${agentId}`;
+            content = `Agent session started: ${GLOBAL_AGENT_ID}`;
             totalTurns = 0;
             successfulTools = 0;
         } else if (event === "agent.run.end" || event === "agent.end") {
             type = "system";
-            content = `Agent session ended: ${agentId}`;
+            content = `Agent session ended: ${GLOBAL_AGENT_ID}`;
         } else if (event.includes("thought") || event.includes("reasoning") || event.includes("think")) {
             totalTurns++;
             latestThought = data.text || data.content || data.message || "Thinking...";
             type = "thought";
             content = latestThought;
         } else if (event.includes("response") || event.includes("message") || event.includes("reply")) {
+            // Check if it's a "chat" message that slipped through? 
+            // Usually agent.message is the agent speaking.
             latestThought = (data.text || data.content || data.message || "").slice(0, 200) || "Response generated";
             type = "thought";
             content = latestThought;
-        } else if (event.includes("error")) {
-            type = "error";
-            content = data.message || data.text || data.error || "Agent error";
+            // Note: Original code had a bug here overwriting type/content immediately after.
+            // I'll fix that logic.
+            if (data.error) {
+                type = "error";
+                content = data.message || data.text || data.error || "Agent error";
+            }
+        }
+
+        // 🧠 Cost & Token Scanner
+        // Scan text for "Cost: $0.XX" or "Tokens: XXX"
+        const txt = data.text || data.content || data.message || "";
+        if (txt) {
+            // Regex to capture 'Cost: $0.00123' or 'cost=$1.23'
+            const costMatch = txt.match(/Cost:?\s*\$([0-9.]+)/i);
+            if (costMatch) {
+                const cost = parseFloat(costMatch[1]);
+                if (!isNaN(cost)) {
+                    dailyCost += cost;
+                    sendToMortgram("cost_update", `Daily spend: $${dailyCost.toFixed(4)}`, { daily_cost: dailyCost, total_tokens: totalTokens });
+                }
+            }
+
+            // Regex to capture 'Tokens: 1234' or 'tokens=5678' or 'token_count: 900'
+            const tokenMatch = txt.match(/Tokens?[_\s]*(?:count)?:?\s*([0-9,]+)/i);
+            if (tokenMatch) {
+                const tokens = parseInt(tokenMatch[1].replace(/,/g, ""), 10);
+                if (!isNaN(tokens)) {
+                    totalTokens += tokens;
+                }
+            }
         }
     } else if (event.startsWith("tool.") || event.startsWith("exec.")) {
         // Tool execution events
@@ -214,7 +310,7 @@ function processEvent(evt) {
         type = "action";
         content = data.name || data.tool || data.command || event;
     } else if (event.startsWith("session.")) {
-        if (event.includes("usage") || event.includes("cost")) {
+        if (event.includes("usage") || event.includes("cost") || event.includes("tokens")) {
             dailyCost = data.total_cost || data.cost || data.totalCost || dailyCost;
             type = "cost_update";
             content = `Daily spend: $${dailyCost.toFixed(4)}`;
@@ -328,6 +424,14 @@ function connect() {
                                 try { ws.ping(); } catch (_) { /* noop */ }
                             }
                         }, 25000);
+
+                        // Start periodic cost updates (every 60s) for "Daily Burn"
+                        if (costTimer) clearInterval(costTimer);
+                        costTimer = setInterval(() => {
+                            if (dailyCost > 0) {
+                                sendToMortgram("cost_update", `Daily spend sync: $${dailyCost.toFixed(4)}`, { daily_cost: dailyCost });
+                            }
+                        }, 60000);
                     }
                 } else {
                     console.error(`\x1b[31m[MORTGRAM] Gateway rejected: ${msg.error?.message || "Unknown"}\x1b[0m`);
@@ -384,9 +488,22 @@ connect();
 function shutdown() {
     console.log("\n\x1b[33m[MORTGRAM] Shutting down...\x1b[0m");
     if (heartbeatTimer) clearInterval(heartbeatTimer);
-    sendToMortgram("system", "Ghost Bridge shutdown", { event: "bridge.shutdown" });
-    if (ws) ws.close();
-    setTimeout(() => process.exit(0), 500);
+    if (costTimer) clearInterval(costTimer);
+
+    // Send final offline status
+    sendToMortgram("status", "Bridge shutting down", {
+        status: "offline", // This maps to "inactive" in UI
+        event: "bridge.shutdown"
+    }).then(() => {
+        if (ws) ws.close();
+        console.log("\x1b[32m[MORTGRAM] Shutdown complete.\x1b[0m");
+        process.exit(0);
+    }).catch(() => {
+        process.exit(1);
+    });
+
+    // Fallback exit if network hangs
+    setTimeout(() => process.exit(0), 2000);
 }
 
 process.on("SIGINT", shutdown);

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "mortgram-bridge",
-    "version": "2.3.0",
-    "description": "MORTGRAM Ghost Bridge — Zero-config OpenClaw event forwarder",
+    "version": "3.0.0",
+    "description": "MORTGRAM Phantom Hook — Zero-latency buffered event forwarder",
     "type": "module",
-    "main": "index.mjs",
+    "main": "phantom.mjs",
     "bin": {
-        "mortgram-bridge": "./index.mjs"
+        "mortgram-bridge": "./phantom.mjs"
     },
     "dependencies": {
         "ws": "^8.18.0"

package/phantom.mjs

@@ -0,0 +1,459 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════════════════════════
+// MORTGRAM Phantom Hook v3.0 — Zero-latency Buffered Event Forwarder
+// ═══════════════════════════════════════════════════════════════════
+// Connects to the OpenClaw Gateway WebSocket and forwards agent/tool
+// events in 500ms batches to the MORTGRAM dashboard API.
+//
+// Usage:
+//   npx mortgram-bridge --token YOUR_MORTGRAM_TOKEN
+//   node bridge/phantom.mjs --token YOUR_MORTGRAM_TOKEN
+// ═══════════════════════════════════════════════════════════════════
+
+import { WebSocket } from "ws";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+
+// ─── CLI Args & Environment ───────────────────────────────────────
+const args = process.argv.slice(2);
+function getArg(name) {
+    const idx = args.indexOf(`--${name}`);
+    return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
+}
+
+function loadEnv() {
+    try {
+        const envPath = path.join(process.cwd(), "bridge", ".env");
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, "utf8");
+            const env = {};
+            for (const line of content.split("\n")) {
+                const match = line.match(/^([^=#]+)=(.*)$/);
+                if (match) {
+                    env[match[1].trim()] = match[2].trim().replace(/^["']|["']$/g, "");
+                }
+            }
+            return env;
+        }
+    } catch (_) { }
+    return {};
+}
+
+const localEnv = loadEnv();
+const env = (key) => getArg(key.toLowerCase().replace(/_/g, "-")) || process.env[key] || localEnv[key] || "";
+
+// ─── Identity (strict env-based) ─────────────────────────────────
+function buildAgentId() {
+    const explicit = env("MORTGRAM_AGENT_ID") || env("AGENT_ID");
+    if (explicit) return explicit;
+    // Deterministic hardware hash fallback
+    try {
+        const hw = `${os.hostname()}-${os.platform()}-${os.arch()}-${os.cpus().length}`;
+        return `agent-${crypto.createHash("sha256").update(hw).digest("hex").substring(0, 12)}`;
+    } catch (_) {
+        return `agent-${Date.now().toString(36)}`;
+    }
+}
+
+const AGENT_ID = buildAgentId();
+const AGENT_NAME = env("MORTGRAM_AGENT_NAME") || env("AGENT_NAME") || "Founder-Main";
+const API_TOKEN = getArg("token") || env("MORTGRAM_API_KEY") || env("MG_LIVE_KEY");
+const API_URL = env("MORTGRAM_API_URL") || "https://mortgram.online/api/ingest";
+const GW_OVERRIDE = getArg("gateway-url");
+
+if (!API_TOKEN) {
+    console.error("\x1b[31m[PHANTOM] FATAL: No --token provided.\x1b[0m");
+    console.error("\x1b[33m  Usage: npx mortgram-bridge --token YOUR_TOKEN\x1b[0m");
+    process.exit(1);
+}
+
+// ─── OpenClaw Config Auto-Detect ──────────────────────────────────
+function detectGateway() {
+    const candidates = [
+        path.join(os.homedir(), ".openclaw", "openclaw.json"),
+        path.join(os.homedir(), ".clawdbot", "clawdbot.json"),
+    ];
+    for (const p of candidates) {
+        try {
+            if (fs.existsSync(p)) {
+                const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+                const port = raw?.gateway?.port || 18789;
+                const token = raw?.gateway?.auth?.token || "";
+                console.log(`\x1b[90m[PHANTOM] Config found: ${p} (port ${port})\x1b[0m`);
+                return { port, token };
+            }
+        } catch (_) { }
+    }
+    return { port: 18789, token: "" };
+}
+
+const gwConfig = detectGateway();
+const GATEWAY_URL = GW_OVERRIDE || `ws://127.0.0.1:${gwConfig.port}`;
+const GATEWAY_TOKEN = gwConfig.token;
+
+// ─── Usage Scraper ────────────────────────────────────────────────
+// High-speed regex parser for OpenAI / Gemini / Anthropic cost data
+class UsageScraper {
+    constructor() {
+        this.totalCost = 0;
+        this.totalTokens = 0;
+        this.model = "unknown";
+
+        // Ordered by specificity — first match wins per category
+        this.costPatterns = [
+            /[Cc]ost:?\s*\$([0-9]+(?:\.[0-9]+)?)/,                        // Cost: $0.0042
+            /total_cost["\s:=]+([0-9]+(?:\.[0-9]+)?)/,                     // "total_cost": 0.05
+            /estimated_cost["\s:=]+\$?([0-9]+(?:\.[0-9]+)?)/i,             // estimated_cost=$0.12
+        ];
+        this.tokenPatterns = [
+            /total_tokens["\s:=]+([0-9,]+)/,                               // "total_tokens": 1234
+            /[Tt]okens?[_\s]*(?:count|used)?:?\s*([0-9,]+)/,               // Tokens: 500
+            /usage[":\s{]+.*?total[_\s]*tokens[":\s]+([0-9,]+)/s,          // usage.total_tokens
+        ];
+        this.modelPatterns = [
+            /model[":\s=]+["']?(gpt-4[^\s"',}]*)/i,                       // gpt-4o, gpt-4-turbo
+            /model[":\s=]+["']?(claude-[^\s"',}]*)/i,                      // claude-3-opus
+            /model[":\s=]+["']?(gemini-[^\s"',}]*)/i,                      // gemini-1.5-pro
+        ];
+    }
+
+    /** Scan a text blob and accumulate cost/token data. Returns true if anything was found. */
+    scan(text) {
+        if (!text || typeof text !== "string") return false;
+        let found = false;
+
+        for (const re of this.costPatterns) {
+            const m = text.match(re);
+            if (m) {
+                const v = parseFloat(m[1]);
+                if (!isNaN(v)) { this.totalCost += v; found = true; }
+                break;
+            }
+        }
+
+        for (const re of this.tokenPatterns) {
+            const m = text.match(re);
+            if (m) {
+                const v = parseInt(m[1].replace(/,/g, ""), 10);
+                if (!isNaN(v)) { this.totalTokens += v; found = true; }
+                break;
+            }
+        }
+
+        for (const re of this.modelPatterns) {
+            const m = text.match(re);
+            if (m) { this.model = m[1]; found = true; break; }
+        }
+
+        return found;
+    }
+
+    snapshot() {
+        return { daily_cost: this.totalCost, total_tokens: this.totalTokens, model: this.model };
+    }
+}
+
+const scraper = new UsageScraper();
+
+// ─── Event Buffer (500ms batch window) ────────────────────────────
+const FLUSH_INTERVAL_MS = 500;
+let eventBuffer = [];
+let flushTimer = null;
+let sessionId = "";
+
+function enqueue(type, content, extra = {}) {
+    eventBuffer.push({ type, content, extra, ts: Date.now() });
+    // Start flush timer if not already running
+    if (!flushTimer) {
+        flushTimer = setTimeout(flushBuffer, FLUSH_INTERVAL_MS);
+    }
+}
+
+async function flushBuffer() {
+    flushTimer = null;
+    if (eventBuffer.length === 0) return;
+
+    // Grab and clear
+    const batch = eventBuffer;
+    eventBuffer = [];
+
+    console.log(`\x1b[36m[PHANTOM] ⚡ Flushing batch of ${batch.length} events\x1b[0m`);
+
+    // Send each event (API expects individual payloads)
+    const usageSnap = scraper.snapshot();
+    for (const evt of batch) {
+        const payload = {
+            agent_id: AGENT_ID,
+            type: evt.type,
+            content: evt.content,
+            metadata: {
+                ...evt.extra,
+                agent_name: AGENT_NAME,
+                daily_cost: usageSnap.daily_cost,
+                total_tokens: usageSnap.total_tokens,
+                model: usageSnap.model,
+                status: "online",
+                session_id: sessionId,
+                timestamp: new Date(evt.ts).toISOString(),
+            },
+        };
+        try {
+            await sendToApi(payload);
+        } catch (err) {
+            console.error(`\x1b[31m[PHANTOM] Send failed: ${err.message}\x1b[0m`);
+            // Re-queue on failure (max once)
+            if (!evt._retried) {
+                evt._retried = true;
+                eventBuffer.push(evt);
+                if (!flushTimer) flushTimer = setTimeout(flushBuffer, 2000);
+            }
+        }
+    }
+}
+
+async function sendToApi(payload) {
+    const res = await fetch(API_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-mortgram-token": API_TOKEN,
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`API ${res.status}: ${body}`);
+    }
+}
+
+// ─── Event Processing (strict filter) ─────────────────────────────
+let eventCount = 0;
+
+function processEvent(evt) {
+    const { event, payload } = evt;
+    const data = payload || {};
+
+    // ═══ STRICT FILTER ═══
+    // ONLY forward agent.* and tool.* events. Everything else is noise.
+    const isAgent = event.startsWith("agent.");
+    const isTool = event.startsWith("tool.") || event.startsWith("exec.");
+    if (!isAgent && !isTool) return;
+
+    eventCount++;
+
+    // Extract session ID if present
+    const sid = data.sessionId || data.session_id || data.runId || evt.sessionId || "";
+    if (sid) sessionId = sid;
+
+    // Scan all text fields for cost/token data
+    const textBlob = [data.text, data.content, data.message, data.output, data.stdout]
+        .filter(Boolean)
+        .join(" ");
+    scraper.scan(textBlob);
+
+    // Also deep-scan if there's a stringified JSON in the payload
+    if (typeof data === "object") {
+        try { scraper.scan(JSON.stringify(data)); } catch (_) { }
+    }
+
+    // Classify event type
+    let type = "log";
+    let content = event;
+
+    if (event === "agent.run.start" || event === "agent.start") {
+        type = "system";
+        content = `Agent session started: ${AGENT_NAME}`;
+    } else if (event === "agent.run.end" || event === "agent.end") {
+        type = "system";
+        content = `Agent session ended: ${AGENT_NAME}`;
+    } else if (event.includes("thought") || event.includes("reasoning") || event.includes("think")) {
+        type = "thought";
+        content = data.text || data.content || data.message || "Thinking...";
+    } else if (event.includes("response") || event.includes("message") || event.includes("reply")) {
+        type = "thought";
+        content = (data.text || data.content || data.message || "").slice(0, 300) || "Response generated";
+        if (data.error) {
+            type = "error";
+            content = data.error || data.message || "Agent error";
+        }
+    } else if (isTool) {
+        type = "action";
+        content = data.name || data.tool || data.command || event;
+    }
+
+    console.log(`\x1b[34m[PHANTOM] 📡 #${eventCount} ${event}\x1b[0m`);
+    enqueue(type, content, { event, seq: evt.seq });
+}
+
+// ─── WebSocket Connection ─────────────────────────────────────────
+let ws = null;
+let connected = false;
+let reconnectDelay = 500;
+let heartbeatTimer = null;
+let costTimer = null;
+
+function sendConnectFrame() {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    const frame = {
+        type: "req",
+        id: crypto.randomUUID(),
+        method: "connect",
+        params: {
+            minProtocol: 3,
+            maxProtocol: 3,
+            client: {
+                id: "phantom-hook",
+                displayName: "MORTGRAM Phantom Hook",
+                version: "3.0.0",
+                platform: process.platform,
+                mode: "backend",
+            },
+            caps: ["tool-events"],
+            auth: GATEWAY_TOKEN ? { token: GATEWAY_TOKEN } : undefined,
+            role: "operator",
+            scopes: ["operator.admin"],
+        },
+    };
+    ws.send(JSON.stringify(frame));
+}
+
+function connect() {
+    if (ws) { try { ws.close(); } catch (_) { } ws = null; }
+
+    console.log(`\x1b[90m[PHANTOM] Connecting to ${GATEWAY_URL}...\x1b[0m`);
+    ws = new WebSocket(GATEWAY_URL, { maxPayload: 25 * 1024 * 1024 });
+
+    ws.on("open", () => {
+        console.log("\x1b[32m[PHANTOM] WebSocket open, sending handshake...\x1b[0m");
+        sendConnectFrame();
+        setTimeout(() => { if (!connected) sendConnectFrame(); }, 100);
+    });
+
+    ws.on("message", (rawData) => {
+        try {
+            const msg = JSON.parse(rawData.toString());
+
+            // Event frame
+            if (msg.event) {
+                if (msg.event === "connect.challenge") {
+                    sendConnectFrame();
+                    return;
+                }
+                processEvent(msg);
+                return;
+            }
+
+            // Response frame (connect ACK)
+            if (msg.id && typeof msg.ok !== "undefined") {
+                if (msg.ok && !connected) {
+                    connected = true;
+                    reconnectDelay = 500;
+                    console.log("\x1b[32m[PHANTOM] ✅ Phantom Hook: LINK ACTIVE\x1b[0m");
+
+                    // Send READY signal to API
+                    enqueue("system", "Phantom Hook connected", {
+                        event: "bridge.connect",
+                        action: "AGENT_READY",
+                        gateway_url: GATEWAY_URL,
+                    });
+
+                    // WebSocket keep-alive pings
+                    if (heartbeatTimer) clearInterval(heartbeatTimer);
+                    heartbeatTimer = setInterval(() => {
+                        if (ws?.readyState === WebSocket.OPEN) {
+                            try { ws.ping(); } catch (_) { }
+                        }
+                    }, 20000);
+
+                    // Periodic cost sync every 30s
+                    if (costTimer) clearInterval(costTimer);
+                    costTimer = setInterval(() => {
+                        const snap = scraper.snapshot();
+                        if (snap.daily_cost > 0) {
+                            enqueue("cost_update", `Daily spend: $${snap.daily_cost.toFixed(4)}`, snap);
+                        }
+                    }, 30000);
+
+                } else if (!msg.ok) {
+                    console.error(`\x1b[31m[PHANTOM] Gateway rejected: ${msg.error?.message || "Unknown"}\x1b[0m`);
+                }
+            }
+        } catch (_) { /* non-JSON, ignore */ }
+    });
+
+    ws.on("close", (code, reason) => {
+        const wasConnected = connected;
+        connected = false;
+        if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+
+        if (wasConnected) {
+            console.log(`\x1b[33m[PHANTOM] Disconnected (${code}): ${reason?.toString() || ""}\x1b[0m`);
+            enqueue("system", "Phantom Hook disconnected", { event: "bridge.disconnect" });
+        }
+
+        console.log(`\x1b[90m[PHANTOM] Reconnecting in ${reconnectDelay / 1000}s...\x1b[0m`);
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+    });
+
+    ws.on("error", () => { /* reconnect via close handler */ });
+}
+
+// ─── Banner ───────────────────────────────────────────────────────
+console.log("");
+console.log("\x1b[35m  ╔══════════════════════════════════════╗\x1b[0m");
+console.log("\x1b[35m  ║   MORTGRAM Phantom Hook v3.0.0       ║\x1b[0m");
+console.log("\x1b[35m  ║   Zero-latency Buffered Forwarder    ║\x1b[0m");
+console.log("\x1b[35m  ╚══════════════════════════════════════╝\x1b[0m");
+console.log("");
+console.log(`\x1b[90m  Agent ID:   ${AGENT_ID}\x1b[0m`);
+console.log(`\x1b[90m  Agent Name: ${AGENT_NAME}\x1b[0m`);
+console.log(`\x1b[90m  Gateway:    ${GATEWAY_URL}\x1b[0m`);
+console.log(`\x1b[90m  Dashboard:  ${API_URL}\x1b[0m`);
+console.log(`\x1b[90m  Buffer:     ${FLUSH_INTERVAL_MS}ms batching\x1b[0m`);
+console.log("");
+
+// ─── Start ────────────────────────────────────────────────────────
+connect();
+
+// ─── Graceful Shutdown ────────────────────────────────────────────
+async function shutdown() {
+    console.log("\n\x1b[33m[PHANTOM] Shutting down...\x1b[0m");
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (costTimer) clearInterval(costTimer);
+
+    // Flush remaining events
+    await flushBuffer();
+
+    // Send final offline ping
+    try {
+        await sendToApi({
+            agent_id: AGENT_ID,
+            type: "status",
+            content: "Phantom Hook shutting down",
+            metadata: {
+                agent_name: AGENT_NAME,
+                status: "offline",
+                session_id: sessionId,
+                event: "bridge.shutdown",
+                timestamp: new Date().toISOString(),
+            },
+        });
+    } catch (_) { /* best effort */ }
+
+    if (ws) ws.close();
+    console.log("\x1b[32m[PHANTOM] Shutdown complete.\x1b[0m");
+    process.exit(0);
+}
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+if (process.platform === "win32") {
+    process.on("SIGBREAK", shutdown);
+}
+
+// Fallback exit
+setTimeout(() => { }, 2147483647); // Keep process alive