@agenthippo-ai/agenthippo 0.1.0

package/out/gateway/service.js

@@ -0,0 +1,1244 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayService = exports.GatewaySessionBindingError = void 0;
+/* eslint-disable local/code-no-unexternalized-strings */
+/**
+ * Gateway Service - Manages connection to OpenClaw Gateway in VS Code
+ *
+ * Key concepts:
+ * - Stable agent IDs: ide-{workspace} or ide-{workspace}-{pack}
+ * - Session routing: disk-backed route index + per-session gateway-session.json
+ * - Publish: user connects an existing IDE session to the gateway
+ */
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const scheduledFleetStorage_js_1 = require("../analytics/dashboard/scheduledFleetStorage.js");
+const bridge_js_1 = require("./bridge.js");
+const gateway_scope_errors_js_1 = require("./gateway-scope-errors.js");
+const gatewayRouteIndex_js_1 = require("./gatewayRouteIndex.js");
+const gatewaySessionStore_js_1 = require("./gatewaySessionStore.js");
+const lifecycle_js_1 = require("./lifecycle.js");
+const openclaw_channel_routing_js_1 = require("./openclaw-channel-routing.js");
+const outboundHandles_js_1 = require("./outboundHandles.js");
+const outboundPaths_js_1 = require("./outboundPaths.js");
+const resetMappings_js_1 = require("./resetMappings.js");
+/** Thrown when a gateway-bound chat cannot be opened without creating a new session (B+E fail-closed). */
+class GatewaySessionBindingError extends Error {
+    userMessage;
+    constructor(sessionId, detail) {
+        const userMessage = `Agent Anywhere cannot open chat session ${sessionId}. ` +
+            `Use "Connect Chat to Gateway" on that chat to reconnect.`;
+        super(detail ? `${userMessage} ${detail}` : userMessage);
+        this.name = "GatewaySessionBindingError";
+        this.userMessage = userMessage;
+    }
+}
+exports.GatewaySessionBindingError = GatewaySessionBindingError;
+// ============================================================================
+// GatewayService
+// ============================================================================
+class GatewayService {
+    extensionContext;
+    bridge = null;
+    outputChannel;
+    config = {};
+    disposables = [];
+    healthCheckTimer = null;
+    static HEALTH_CHECK_INTERVAL = 30000;
+    static MAX_SESSIONS = 20;
+    /** Runtime cache: AgentHippo sessionId -> active VS Code chat binding. */
+    sessionCache = new Map();
+    // Gateway emitter correlation (unchanged from before)
+    static gatewayEmitters = new Map();
+    static getGatewayEmitter(token) {
+        const emitter = GatewayService.gatewayEmitters.get(token);
+        if (emitter) {
+            GatewayService.gatewayEmitters.delete(token);
+        }
+        return emitter;
+    }
+    constructor(extensionContext, outputChannel) {
+        this.extensionContext = extensionContext;
+        this.outputChannel = outputChannel;
+        this.registerCommands();
+        this.disposables.push(vscode.workspace.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration("agentide.gateway")) {
+                this.loadConfig();
+            }
+        }));
+        this.loadConfig();
+    }
+    // ============================================================================
+    // Config
+    // ============================================================================
+    loadConfig() {
+        const config = vscode.workspace.getConfiguration("agentide.gateway");
+        this.config = {
+            url: config.get("url"),
+            token: config.get("token"),
+            autoConnect: config.get("autoConnect", false),
+            autoRegister: config.get("autoRegister", true),
+            workspaceName: config.get("workspaceName"),
+            agents: config.get("agents"),
+        };
+        if (this.config.autoConnect && this.config.url && !this.isConnected) {
+            void this.connect({ silent: true });
+        }
+    }
+    // ============================================================================
+    // Stable Agent IDs
+    // ============================================================================
+    /**
+     * Derive workspace name from VS Code workspace folder or setting.
+     * E.g., /Users/me/dev/frontend -> "frontend"
+     */
+    resolveWorkspaceName() {
+        const configured = this.config.workspaceName?.trim();
+        if (configured) {
+            return this.slugify(configured);
+        }
+        const folder = vscode.workspace.workspaceFolders?.[0];
+        if (folder) {
+            const folderName = folder.uri.path.split("/").pop() || "workspace";
+            return this.slugify(folderName);
+        }
+        return "workspace";
+    }
+    /**
+     * Build stable agent ID: ide-{workspace} or ide-{workspace}-{pack}
+     */
+    resolveAgentId(packName) {
+        const ws = this.resolveWorkspaceName();
+        if (!packName || packName === "default" || packName === "Default") {
+            return `ide-${ws}`;
+        }
+        return `ide-${ws}-${this.slugify(packName)}`;
+    }
+    slugify(str) {
+        return str
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "")
+            .slice(0, 32) || "unnamed";
+    }
+    // ============================================================================
+    // Commands
+    // ============================================================================
+    registerCommands() {
+        this.disposables.push(vscode.commands.registerCommand("agentide.gateway.connect", () => this.connect()), vscode.commands.registerCommand("agentide.gateway.disconnect", () => this.disconnect()), vscode.commands.registerCommand("agentide.gateway.toggle", () => {
+            return this.isConnected ? this.disconnect() : this.connect();
+        }), vscode.commands.registerCommand("agentide.gateway.status", () => this.showStatus()), vscode.commands.registerCommand("agentide.gateway.connectSession", () => this.publishCurrentSession()), vscode.commands.registerCommand("agentide.gateway.listSessions", () => this.showSessionMap()), vscode.commands.registerCommand("agentide.gateway.resetMappings", () => this.resetMappings()));
+    }
+    // ============================================================================
+    // Reset mappings (forget learned inbound/outbound routing for an agent)
+    // ============================================================================
+    /**
+     * Forget an agent's learned routing so new Slack/Telegram messages start fresh chats. Backs up
+     * (never deletes) the route index, default chat, and per-chat outbound stores to `.bk` files.
+     * Channel bindings and chat history are kept. Works offline — pure local file operations.
+     */
+    async resetMappings() {
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        const agentId = await this.resolveResetMappingsAgentId();
+        if (!agentId) {
+            vscode.window.showWarningMessage("No agent found to reset. Open a chat or register an agent first.");
+            return;
+        }
+        // Cheap pre-check so we don't pop a modal when there is nothing to forget.
+        const index = await (0, gatewayRouteIndex_js_1.readGatewayRouteIndex)(workspaceRoot);
+        const prefix = `${agentId}::`;
+        const routeCount = Object.keys(index.byRoute).filter((k) => k.startsWith(prefix)).length;
+        const hasDefault = Boolean(await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, agentId));
+        if (routeCount === 0 && !hasDefault) {
+            vscode.window.showInformationMessage(`${agentId}: no mappings to reset.`);
+            return;
+        }
+        const confirm = await vscode.window.showWarningMessage(`Reset mappings for "${agentId}"? New messages will start fresh chats. ` +
+            `Your channels, chats, and history are kept; old mappings are saved as .bk files.`, { modal: true }, "Reset");
+        if (confirm !== "Reset") {
+            return;
+        }
+        try {
+            const result = await (0, resetMappings_js_1.resetAgentMappings)(workspaceRoot, agentId);
+            // Drop in-memory routes for this agent so the Sessions list reflects reality at once.
+            for (const [id, entry] of this.sessionCache) {
+                if (entry.agentId === agentId) {
+                    this.sessionCache.delete(id);
+                }
+            }
+            const parts = [`${result.routes} mapping${result.routes === 1 ? "" : "s"}`];
+            if (result.sessions > 0) {
+                parts.push(`${result.sessions} chat${result.sessions === 1 ? "" : "s"}`);
+            }
+            if (result.hadDefault) {
+                parts.push("default chat");
+            }
+            vscode.window.showInformationMessage(`Reset ${parts.join(", ")} for ${agentId}. Originals saved as .bk.`);
+        }
+        catch (err) {
+            this.log(`Reset mappings failed: ${err}`);
+            vscode.window.showErrorMessage(`Failed to reset mappings: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Resolve which agent "Reset mappings" should target: the current chat's agent when a chat is
+     * focused, otherwise a pick across registered agents (single registered agent is auto-selected).
+     */
+    async resolveResetMappingsAgentId() {
+        try {
+            const chatState = await this.queryChatState();
+            if (chatState?.sessionId) {
+                return this.resolveAgentId(chatState.activePackId || "default");
+            }
+        }
+        catch {
+            // Fall through to the registered-agent picker.
+        }
+        const agents = this.bridge?.registeredAgents ?? [];
+        if (agents.length === 1) {
+            return agents[0];
+        }
+        if (agents.length === 0) {
+            return undefined;
+        }
+        return vscode.window.showQuickPick(agents, {
+            title: "Reset mappings for which agent?",
+            placeHolder: "Select the agent whose learned routing to forget",
+        });
+    }
+    // ============================================================================
+    // Publish (Connect Existing Session to Gateway) - Phase 3
+    // ============================================================================
+    /**
+     * Publish the current VS Code chat session to the gateway.
+     * Shows a picker to choose who this session is for:
+     * - A specific known peer (e.g., @x via telegram)
+     * - Default fallback (web UI and unmatched inbound routes — not every channel/thread)
+     */
+    async publishCurrentSession(retryAttempt = 0) {
+        if (!this.isConnected) {
+            // Route through the lifecycle command so it owns the status-bar bookkeeping
+            // (setBridgeConnected + setStatus("running")). connectBridge() delegates back to
+            // this.connect() via _bridgeRef, so a direct call here would connect the bridge
+            // but leave the Agent Anywhere status bar stuck on "Disconnected".
+            await vscode.commands.executeCommand("agentide.anywhere.connect");
+        }
+        if (!this.bridge) {
+            vscode.window.showErrorMessage("Not connected to Gateway");
+            return;
+        }
+        try {
+            const chatState = await this.queryChatState();
+            if (!chatState?.sessionId || !chatState?.sessionResource) {
+                vscode.window.showErrorMessage("No active chat session found.");
+                return;
+            }
+            const packName = chatState.activePackId || "default";
+            const agentId = this.resolveAgentId(packName);
+            const sessionId = chatState.sessionId;
+            const sessionResource = vscode.Uri.parse(chatState.sessionResource);
+            const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+            await this.ensureAgentRegistered(agentId, packName);
+            const peerItems = [
+                {
+                    label: "$(globe) Default for new routes",
+                    description: "New Slack/Telegram threads use this chat; existing routes unchanged",
+                    routeKey: undefined,
+                },
+            ];
+            const seenPeers = new Set();
+            for (const entry of this.sessionCache.values()) {
+                if (entry.agentId === agentId && entry.peerLabel && !seenPeers.has(entry.peerLabel)) {
+                    seenPeers.add(entry.peerLabel);
+                    peerItems.push({
+                        label: `$(person) ${entry.peerLabel}`,
+                        description: `Bind this chat to ${entry.peerLabel}`,
+                        routeKey: entry.gatewaySessionKey,
+                    });
+                }
+            }
+            let selectedRouteKey;
+            if (peerItems.length > 1) {
+                const picked = await vscode.window.showQuickPick(peerItems, {
+                    title: "Connect Chat to Gateway",
+                    placeHolder: "Who should this chat session serve?",
+                });
+                if (!picked) {
+                    return;
+                }
+                selectedRouteKey = picked.routeKey;
+            }
+            let peerRoute;
+            let seedGatewaySessionKey;
+            let seedChannel;
+            if (selectedRouteKey) {
+                const dmMatch = selectedRouteKey.match(/:dm:(.+)$/i);
+                const channelMatch = selectedRouteKey.match(/:(channel|thread|group|chat):([^:]+)$/i);
+                peerRoute = dmMatch?.[1]
+                    ? `dm:${dmMatch[1]}`
+                    : channelMatch
+                        ? `${channelMatch[1].toLowerCase()}:${channelMatch[2]}`
+                        : selectedRouteKey;
+                seedGatewaySessionKey = selectedRouteKey;
+                const cached = [...this.sessionCache.values()].find((e) => e.gatewaySessionKey === selectedRouteKey);
+                seedChannel = cached?.channel;
+            }
+            const sessionTitleTrim = chatState.sessionTitle?.trim();
+            const bindLabel = !peerRoute && sessionTitleTrim && sessionTitleTrim.length > 0
+                ? (0, gatewaySessionStore_js_1.normalizeInboundBindLabel)(sessionTitleTrim)
+                : undefined;
+            const publishedMode = peerRoute ? "peer" : "default";
+            const existingRecord = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, sessionId);
+            // Guard (a) — double-connect: this chat is already bound to a route/default.
+            // Confirm, then clear its prior mappings so we reconnect cleanly (per spec: "clear our
+            // connected session and reconnect this session anew").
+            if (existingRecord?.published) {
+                const prior = this.describePublishedTarget(existingRecord.published);
+                const choice = await vscode.window.showWarningMessage(`This chat is already connected to Agent Anywhere (${prior}). Clear that connection and reconnect this chat anew?`, "Clear & Reconnect");
+                if (choice !== "Clear & Reconnect") {
+                    return;
+                }
+                const removedRoutes = await (0, gatewayRouteIndex_js_1.removeRouteSessionMappingsForSession)(workspaceRoot, agentId, sessionId);
+                await (0, gatewayRouteIndex_js_1.clearDefaultPublishedSessionId)(workspaceRoot, agentId, sessionId);
+                this.log(`Cleared prior gateway mapping for chat ${sessionId} (routes: ${removedRoutes.join(", ") || "none"})`);
+            }
+            // Guard (b) — clobber: the route/default we're about to claim is already served by a
+            // different chat. Confirm reassignment before stealing it, and remember the previous
+            // owner(s) so we can scrub their now-stale binding after the new mapping is written.
+            let reassignedDefaultOwner;
+            const reassignedRouteOwners = new Map();
+            if (publishedMode === "default") {
+                const currentDefault = await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, agentId);
+                if (currentDefault && currentDefault !== sessionId) {
+                    if (!(await this.confirmRouteReassignment(workspaceRoot, "Default for new inbound routes", currentDefault))) {
+                        return;
+                    }
+                    reassignedDefaultOwner = currentDefault;
+                }
+            }
+            else {
+                const claimKeys = [...new Set([selectedRouteKey, peerRoute].filter((k) => !!k))];
+                for (const key of claimKeys) {
+                    const owner = await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, agentId, key);
+                    if (owner && owner !== sessionId) {
+                        if (!(await this.confirmRouteReassignment(workspaceRoot, `Route "${key}"`, owner))) {
+                            return;
+                        }
+                        const keys = reassignedRouteOwners.get(owner) ?? new Set();
+                        keys.add(key);
+                        reassignedRouteOwners.set(owner, keys);
+                    }
+                }
+            }
+            const gatewaySessionKeys = (0, gatewaySessionStore_js_1.mergeGatewaySessionKeyList)(existingRecord?.gatewaySessionKeys ?? [], seedGatewaySessionKey);
+            await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
+                version: 1,
+                sessionId,
+                agentId,
+                packName,
+                vscodeSessionResource: sessionResource.toString(),
+                chatMode: chatState.mode,
+                published: {
+                    mode: publishedMode,
+                    peerRoute,
+                    bindLabel: bindLabel && bindLabel.length > 0 ? bindLabel : undefined,
+                    at: new Date().toISOString(),
+                },
+                gatewaySessionKeys,
+                updatedAt: new Date().toISOString(),
+            });
+            if ((0, gatewaySessionStore_js_1.shouldUpdateAgentDefaultOnGatewayPublish)(publishedMode)) {
+                await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, agentId, sessionId);
+            }
+            if (selectedRouteKey) {
+                await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, agentId, selectedRouteKey, sessionId);
+            }
+            if (peerRoute) {
+                await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, agentId, peerRoute, sessionId);
+            }
+            // New mappings are in place — scrub the reassigned binding from its previous owner so a
+            // stale leading sessionKey can't misroute that chat's outbound and its `published` no
+            // longer claims a route it lost. Delete the record only if fully orphaned (see § clobber).
+            if (reassignedDefaultOwner) {
+                const scrubbed = await (0, gatewaySessionStore_js_1.clearGatewaySessionPublishedDefault)(workspaceRoot, reassignedDefaultOwner);
+                await this.deleteOrphanedGatewayRecord(workspaceRoot, agentId, reassignedDefaultOwner, scrubbed);
+            }
+            for (const [owner, keys] of reassignedRouteOwners) {
+                const scrubbed = await (0, gatewaySessionStore_js_1.detachGatewaySessionRoutes)(workspaceRoot, owner, [...keys]);
+                await this.deleteOrphanedGatewayRecord(workspaceRoot, agentId, owner, scrubbed);
+            }
+            const entry = {
+                gatewaySessionKey: seedGatewaySessionKey ?? `__published__:${agentId}`,
+                agentId,
+                packName,
+                vscodeSessionResource: sessionResource,
+                chatSessionId: sessionId,
+                chatMode: chatState.mode,
+                lastActiveAt: Date.now(),
+                channel: seedChannel,
+            };
+            this.sessionCache.set(sessionId, entry);
+            const boundChannels = await this.bindPublishedGatewayChannels(agentId, seedChannel);
+            if (seedGatewaySessionKey) {
+                this.seedPublishedGatewayOutbound(packName, agentId, sessionId, seedGatewaySessionKey, seedChannel);
+            }
+            this.updateStatusBar("connected");
+            const displayName = bindLabel ?? (sessionTitleTrim && sessionTitleTrim.length > 0 ? sessionTitleTrim : undefined);
+            const chatDesc = displayName ? `Chat "${displayName}"` : "New chat";
+            const target = peerRoute
+                ? `route "${peerRoute}"`
+                : "default for new inbound routes";
+            this.log(`Published ${chatDesc} (${sessionId}) as ${agentId} for ${target}`);
+            const bindHint = bindLabel && bindLabel.length > 0
+                ? ` Use hippoclaw agent --session-id "${bindLabel}" to reach this chat.`
+                : "";
+            const channelHint = boundChannels.length > 0
+                ? ` Reachable from: ${boundChannels.join(", ")}.`
+                : "";
+            vscode.window.showInformationMessage(`${chatDesc} connected to Gateway for ${target}.${channelHint}${bindHint}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // The gateway may require a reconnect if the extension connected with stale auth/scopes.
+            const shouldRetry = retryAttempt < 1 &&
+                ((0, gateway_scope_errors_js_1.isGatewayScopeAuthError)(message) || message.toLowerCase().includes("connection closed"));
+            if (shouldRetry) {
+                this.log(`publishCurrentSession failed (${message}); reconnecting and retrying...`);
+                try {
+                    await this.disconnect();
+                    await this.connect();
+                    return await this.publishCurrentSession(retryAttempt + 1);
+                }
+                catch {
+                    // Fall through to error message
+                }
+            }
+            vscode.window.showErrorMessage(`Failed to publish session: ${message}`);
+        }
+    }
+    // ============================================================================
+    // Session Resolution - Phase 2
+    // ============================================================================
+    /**
+     * Build a human-readable label for a peer from their info.
+     */
+    /** Human-readable description of what a chat's existing publish points at (for the reconnect prompt). */
+    describePublishedTarget(published) {
+        if (published.mode === "peer" && published.peerRoute) {
+            return `route "${published.peerRoute}"`;
+        }
+        if (published.bindLabel) {
+            return `CLI label "${published.bindLabel}"`;
+        }
+        return "default for new inbound routes";
+    }
+    /**
+     * Confirm reassigning a route/default that another chat currently owns. Returns true to proceed.
+     * Dismissing the toast (no choice) cancels — we never silently clobber an existing binding.
+     */
+    async confirmRouteReassignment(workspaceRoot, targetDesc, ownerSessionId) {
+        const ownerRecord = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, ownerSessionId);
+        const ownerLabel = ownerRecord?.published?.bindLabel?.trim() ||
+            ownerRecord?.published?.peerRoute?.trim() ||
+            ownerSessionId;
+        const choice = await vscode.window.showWarningMessage(`${targetDesc} is currently served by another chat ("${ownerLabel}"). Reassign it to this chat? The other chat will stop receiving those messages.`, "Reassign");
+        return choice === "Reassign";
+    }
+    /** Remove a scrubbed owner's binding record once it holds no routes/published and is not the agent default. */
+    async deleteOrphanedGatewayRecord(workspaceRoot, agentId, ownerSessionId, scrubbed) {
+        if (!scrubbed || !(0, gatewaySessionStore_js_1.isGatewaySessionRecordOrphaned)(scrubbed)) {
+            return;
+        }
+        const currentDefault = await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, agentId);
+        if (currentDefault === ownerSessionId) {
+            return; // Still the agent default (published cleared but pointer remains) — keep the record.
+        }
+        await (0, gatewaySessionStore_js_1.deleteGatewaySessionRecord)(workspaceRoot, ownerSessionId);
+        this.log(`Removed orphaned gateway record for chat ${ownerSessionId}`);
+    }
+    buildPeerLabel(peerInfo) {
+        if (!peerInfo) {
+            return undefined;
+        }
+        const name = peerInfo.senderUsername || peerInfo.senderName || peerInfo.senderId;
+        if (!name) {
+            return undefined;
+        }
+        const channel = peerInfo.channel ? ` via ${peerInfo.channel}` : "";
+        return `${name}${channel}`;
+    }
+    async resolveOrCreateSession(agentId, sessionKey, packName, peerInfo, gatewayWireSessionId) {
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        const routeKey = sessionKey;
+        const resolution = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId,
+            routeKey,
+            gatewaySessionKey: sessionKey,
+            gatewayWireSessionId,
+        });
+        // The default published session is a one-shot catch for the first unmatched inbound. Claim it
+        // atomically so a burst of messages from *different* channels (e.g. a Slack backlog flushed on
+        // reconnect) can't all collapse onto it — only the first winner keeps the default chat and
+        // persists its route mapping; the rest fall through to their own per-channel chat below.
+        let sessionId = resolution.sessionId;
+        if (resolution.source === "defaultPublished") {
+            sessionId = await (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, agentId);
+        }
+        if (resolution.source === "new" || !sessionId) {
+            const peerLabel = this.buildPeerLabel(peerInfo);
+            this.log(`Creating new VS Code session for peer: ${peerLabel ?? sessionKey ?? "unknown"}, agent=${agentId}`);
+            return this.createNewGatewaySession(agentId, sessionKey, packName, peerInfo, resolution.persistRouteKey);
+        }
+        let entry = this.sessionCache.get(sessionId);
+        if (!entry) {
+            entry = await this.hydrateSessionEntryFromDisk(workspaceRoot, sessionId, agentId, packName);
+        }
+        if (!entry) {
+            this.log(`Session record missing for ${sessionId}; creating new chat and remapping route`);
+            const created = await this.createNewGatewaySession(agentId, sessionKey, packName, peerInfo, resolution.persistRouteKey);
+            if (resolution.persistRouteKey) {
+                await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, agentId, resolution.persistRouteKey, created.chatSessionId);
+            }
+            return created;
+        }
+        entry.lastActiveAt = Date.now();
+        entry.gatewaySessionKey = sessionKey ?? entry.gatewaySessionKey;
+        const peerLabel = this.buildPeerLabel(peerInfo);
+        if (peerLabel && !entry.peerLabel) {
+            entry.peerLabel = peerLabel;
+        }
+        if (peerInfo?.channel) {
+            entry.channel = peerInfo.channel;
+        }
+        await this.ensureChatSessionOpen(entry, workspaceRoot);
+        if (resolution.persistRouteKey) {
+            await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, agentId, resolution.persistRouteKey, sessionId);
+            await (0, gatewaySessionStore_js_1.appendGatewaySessionKey)(workspaceRoot, sessionId, resolution.persistRouteKey);
+        }
+        this.sessionCache.set(sessionId, entry);
+        this.evictStaleSessionCache();
+        return entry;
+    }
+    async hydrateSessionEntryFromDisk(workspaceRoot, sessionId, agentId, packName) {
+        const record = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, sessionId);
+        if (!record) {
+            return undefined;
+        }
+        return {
+            gatewaySessionKey: record.gatewaySessionKeys[0] ?? `__published__:${agentId}`,
+            agentId: record.agentId,
+            packName: record.packName || packName,
+            vscodeSessionResource: vscode.Uri.parse(record.vscodeSessionResource),
+            chatSessionId: record.sessionId,
+            chatMode: record.chatMode,
+            lastActiveAt: Date.now(),
+        };
+    }
+    /**
+     * Open the gateway-bound VS Code chat (B: workbench restore only; E: fail closed, no newChat).
+     * Session folder id remains {@link GatewaySessionEntry.chatSessionId}.
+     */
+    async ensureChatSessionOpen(entry, workspaceRoot) {
+        const sessionId = entry.chatSessionId;
+        const candidates = [];
+        const stored = entry.vscodeSessionResource.toString();
+        if (stored) {
+            candidates.push(stored);
+        }
+        const canonical = (0, scheduledFleetStorage_js_1.buildChatSessionResourceFromSessionId)(sessionId);
+        if (canonical && !candidates.includes(canonical)) {
+            candidates.push(canonical);
+        }
+        const failures = [];
+        for (const sessionResource of candidates) {
+            const result = await vscode.commands.executeCommand("agentide.openChatSession", { sessionId, sessionResource });
+            if (result?.success) {
+                const openedResource = result.sessionResource;
+                if (openedResource && openedResource !== stored) {
+                    entry.vscodeSessionResource = vscode.Uri.parse(openedResource);
+                    await (0, gatewaySessionStore_js_1.updateGatewaySessionResource)(workspaceRoot, sessionId, openedResource, entry.chatMode);
+                }
+                return;
+            }
+            const reason = result && !result.success ? result.reason : "command_unavailable";
+            failures.push(`${sessionResource}: ${reason}`);
+        }
+        this.log(`Gateway could not open chat session ${sessionId} (${failures.join("; ")})`);
+        throw new GatewaySessionBindingError(sessionId);
+    }
+    async createNewGatewaySession(agentId, sessionKey, packName, peerInfo, persistRouteKey) {
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        await vscode.commands.executeCommand("workbench.action.chat.newChat");
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const chatState = await this.queryChatState();
+        if (!chatState?.sessionId || !chatState?.sessionResource) {
+            throw new Error("Failed to create new chat session");
+        }
+        const sessionId = chatState.sessionId;
+        const sessionResource = vscode.Uri.parse(chatState.sessionResource);
+        const gatewaySessionKey = sessionKey ?? `__created__:${agentId}:${sessionId}`;
+        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
+            version: 1,
+            sessionId,
+            agentId,
+            packName,
+            vscodeSessionResource: sessionResource.toString(),
+            chatMode: chatState.mode,
+            gatewaySessionKeys: gatewaySessionKey ? [gatewaySessionKey] : [],
+            updatedAt: new Date().toISOString(),
+        });
+        if (persistRouteKey) {
+            await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, agentId, persistRouteKey, sessionId);
+        }
+        const entry = {
+            gatewaySessionKey,
+            agentId,
+            packName,
+            vscodeSessionResource: sessionResource,
+            chatSessionId: sessionId,
+            chatMode: chatState.mode,
+            peerLabel: this.buildPeerLabel(peerInfo),
+            channel: peerInfo?.channel,
+            lastActiveAt: Date.now(),
+        };
+        this.sessionCache.set(sessionId, entry);
+        this.evictStaleSessionCache();
+        return entry;
+    }
+    evictStaleSessionCache() {
+        while (this.sessionCache.size > GatewayService.MAX_SESSIONS) {
+            let oldestId;
+            let oldestTime = Infinity;
+            for (const [id, entry] of this.sessionCache) {
+                if (entry.lastActiveAt < oldestTime) {
+                    oldestTime = entry.lastActiveAt;
+                    oldestId = id;
+                }
+            }
+            if (oldestId) {
+                this.log(`Evicting stale session cache: ${oldestId}`);
+                this.sessionCache.delete(oldestId);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    // ============================================================================
+    // Chat UI Handler (session-aware)
+    // ============================================================================
+    resolveGatewayWorkspaceRoot() {
+        const folder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+        if (folder) {
+            return folder;
+        }
+        const dirName = vscode.workspace.getConfiguration("agentide").get("fallbackDirectory") || ".agent-hippo";
+        return path.join(os.homedir(), dirName);
+    }
+    async bindPublishedGatewayChannels(agentId, preferredChannel) {
+        if (!this.bridge?.isConnected) {
+            return [];
+        }
+        const request = this.bridge.request.bind(this.bridge);
+        const { rows, statusPayload } = await (0, openclaw_channel_routing_js_1.fetchMeetAgentChannelContext)(request);
+        const selectedChannels = (0, openclaw_channel_routing_js_1.resolvePublishedGatewayChannelIds)(rows, preferredChannel);
+        if (selectedChannels.length === 0) {
+            return [];
+        }
+        const patched = await (0, openclaw_channel_routing_js_1.applyAgentChannelBindingsViaConfigPatch)(request, {
+            agentId,
+            selectedChannelIds: selectedChannels,
+            statusPayload,
+        });
+        this.log(patched
+            ? `Bound ${agentId} to gateway channels: ${selectedChannels.join(", ")}`
+            : `${agentId} gateway channel bindings already current: ${selectedChannels.join(", ")}`);
+        // A real binding patch can bounce the affected channel; wait for the channels that were live
+        // before the patch to come back before we report success, otherwise an inbound message in the
+        // restart window is dropped or routed to the gateway's embedded agent (the "publish didn't
+        // take the first time, worked on the second click" symptom). Only wait on channels that were
+        // actually live pre-patch — a configured-but-offline channel (e.g. stalled Telegram polling)
+        // must not block publish. No patch ⇒ nothing restarted ⇒ skip the wait.
+        if (patched) {
+            const liveBefore = new Set(rows.filter((r) => r.connected).map((r) => r.id.trim().toLowerCase()));
+            const awaitable = selectedChannels.filter((id) => liveBefore.has(id.trim().toLowerCase()));
+            if (awaitable.length > 0) {
+                const settle = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, awaitable);
+                this.log(settle.ready
+                    ? `Gateway channels live after bind: ${settle.live.join(", ")}`
+                    : `Gateway channels not confirmed live after bind (timed out after ${settle.polls} poll(s)); pending: ${settle.pending.join(", ")}`);
+            }
+        }
+        return selectedChannels;
+    }
+    persistIdeGatewayOutbound(agentId, gatewayAgentId, sessionEntry, runContext) {
+        if (!runContext) {
+            return;
+        }
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        const chatSessionId = sessionEntry.chatSessionId ||
+            (0, scheduledFleetStorage_js_1.parseSessionIdFromChatResource)(sessionEntry.vscodeSessionResource.toString());
+        if (!chatSessionId) {
+            return;
+        }
+        const storePath = (0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, chatSessionId);
+        void (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, agentId, runContext.params, runContext.runId, {
+            gatewayAgentId,
+        })
+            .then((handle) => {
+            if (handle) {
+                this.log(`Gateway outbound routes: ${storePath}`);
+            }
+        })
+            .catch((err) => {
+            this.log(`Failed to persist outbound handle: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    seedPublishedGatewayOutbound(agentId, gatewayAgentId, chatSessionId, gatewaySessionKey, channel) {
+        const sourceSessionDirId = (0, outboundPaths_js_1.resolveGatewaySessionDirId)({ gatewaySessionKey });
+        if (!sourceSessionDirId) {
+            return;
+        }
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        const sourceStorePath = (0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, sourceSessionDirId);
+        const targetStorePath = (0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, chatSessionId);
+        void (0, outboundHandles_js_1.mergeGatewayOutboundHandles)(sourceStorePath, targetStorePath, agentId)
+            .then(async (merged) => {
+            if (merged > 0) {
+                this.log(`Gateway outbound routes: ${targetStorePath} (seeded from ${sourceStorePath})`);
+                return;
+            }
+            const handle = await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(targetStorePath, agentId, {
+                message: "",
+                channel,
+                sessionKey: gatewaySessionKey,
+                idempotencyKey: `publish:${Date.now()}`,
+            }, undefined, {
+                gatewayAgentId,
+            });
+            if (handle) {
+                this.log(`Gateway outbound routes: ${targetStorePath}`);
+            }
+        })
+            .catch((err) => {
+            this.log(`Failed to seed outbound handle: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    /**
+     * Create a session-aware Chat UI handler.
+     * Uses sessionKey + peerInfo to resolve the correct VS Code session.
+     */
+    createSessionAwareChatUIHandler(agentId, packName) {
+        return async (message, sessionKey, peerInfo, emitter, runContext) => {
+            const gatewayRequestToken = `gw-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            GatewayService.gatewayEmitters.set(gatewayRequestToken, emitter);
+            const markedMessage = `[gw:${gatewayRequestToken}]${message}`;
+            try {
+                const sessionEntry = await this.resolveOrCreateSession(agentId, sessionKey, packName, peerInfo, runContext?.params.sessionId);
+                const sessionResource = sessionEntry.vscodeSessionResource;
+                this.persistIdeGatewayOutbound(packName, agentId, sessionEntry, runContext);
+                const peerLabel = this.buildPeerLabel(peerInfo);
+                const sessionInfo = `session=${sessionResource.toString()}, peer=${peerLabel ?? "unknown"}, sessionKey=${sessionKey ?? "none"}`;
+                this.log(`Routing gateway message to Chat UI (${sessionInfo}): ${message.slice(0, 50)}...`);
+                const commandParams = {
+                    query: markedMessage,
+                    blockOnResponse: true,
+                    sessionResource: sessionResource.toString(),
+                };
+                commandParams.mode = sessionEntry.chatMode?.trim() || "agent";
+                const result = await vscode.commands.executeCommand("workbench.action.chat.open", commandParams);
+                if (result?.errorDetails?.message) {
+                    return `[Error: ${result.errorDetails.message}]`;
+                }
+                return result?.responseText || "[Chat response completed]";
+            }
+            catch (err) {
+                if (err instanceof GatewaySessionBindingError) {
+                    this.log(`Gateway session binding lost: ${err.message}`);
+                    void vscode.window.showWarningMessage(err.userMessage);
+                    await emitter.error(err.userMessage);
+                    return `[Error: ${err.userMessage}]`;
+                }
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                this.log(`Chat UI handler error: ${errorMsg}`);
+                await emitter.error(errorMsg);
+                throw err;
+            }
+            finally {
+                GatewayService.gatewayEmitters.delete(gatewayRequestToken);
+            }
+        };
+    }
+    // ============================================================================
+    // Agent Registration
+    // ============================================================================
+    /**
+     * Ensure an agent is registered with the gateway.
+     * Idempotent: re-registering with the same ID is a no-op.
+     */
+    async ensureAgentRegistered(agentId, packName, scopeRetryDepth = 0) {
+        if (!this.bridge) {
+            return;
+        }
+        // Check if already registered
+        if (this.bridge.registeredAgents.includes(agentId)) {
+            return;
+        }
+        const chatUIHandler = this.createSessionAwareChatUIHandler(agentId, packName);
+        const agent = {
+            id: agentId,
+            agentId: packName,
+            name: `${packName} (${this.resolveWorkspaceName()})`,
+            workspace: this.resolveGatewayWorkspaceRoot(),
+            useChatUI: true,
+            chatUIHandler,
+        };
+        try {
+            await this.bridge.registerAgent(agent);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (scopeRetryDepth >= 1 || !(0, gateway_scope_errors_js_1.isGatewayScopeAuthError)(message)) {
+                throw err;
+            }
+            // Scopes are fixed at WebSocket handshake time. A connection opened before the
+            // extension sent operator scopes will keep failing agents.register until we reconnect.
+            // Use bridge.reconnect() (not service.disconnect) so the session map stays intact.
+            this.log("Gateway denied RPC (missing operator scope); reconnecting with a fresh handshake...");
+            await this.bridge.reconnect();
+            await this.registerConfiguredAgents();
+            await this.ensureAgentRegistered(agentId, packName, scopeRetryDepth + 1);
+            return;
+        }
+        this.log(`Registered agent: ${agentId}`);
+    }
+    /**
+     * Register agents from settings on connect.
+     */
+    async registerConfiguredAgents() {
+        if (!this.bridge) {
+            return;
+        }
+        // Auto-register active pack
+        if (this.config.autoRegister) {
+            try {
+                const chatState = await this.queryChatState();
+                const packName = chatState?.activePackId || "default";
+                const agentId = this.resolveAgentId(packName);
+                await this.ensureAgentRegistered(agentId, packName);
+            }
+            catch (err) {
+                this.log(`Failed to auto-register active pack: ${err}`);
+            }
+        }
+        // Register explicitly configured packs
+        if (this.config.agents?.length) {
+            for (const agentConfig of this.config.agents) {
+                try {
+                    const agentId = this.resolveAgentId(agentConfig.pack);
+                    await this.ensureAgentRegistered(agentId, agentConfig.pack);
+                }
+                catch (err) {
+                    this.log(`Failed to register pack ${agentConfig.pack}: ${err}`);
+                }
+            }
+        }
+    }
+    // ============================================================================
+    // Session New (from Gateway) - Phase 4
+    // ============================================================================
+    async handleSessionNewRequest(request) {
+        const { requestId, params } = request;
+        this.log(`Creating new session from Gateway (requestedBy=${params.requestedBy}, sessionKey=${params.sessionKey})`);
+        try {
+            await vscode.commands.executeCommand("workbench.action.chat.newChat");
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            const chatState = await this.queryChatState();
+            if (!chatState?.sessionId || !chatState?.sessionResource) {
+                this.bridge?.respondSessionNew(requestId, {
+                    success: false,
+                    error: "Failed to create chat session",
+                });
+                return;
+            }
+            const sessionResource = vscode.Uri.parse(chatState.sessionResource);
+            const packName = chatState.activePackId || "default";
+            const agentId = this.resolveAgentId(packName);
+            // Ensure agent is registered
+            await this.ensureAgentRegistered(agentId, packName);
+            const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+            const sessionId = chatState.sessionId;
+            const newTitleTrim = chatState.sessionTitle?.trim();
+            const bindLabel = newTitleTrim && newTitleTrim.length > 0 ? (0, gatewaySessionStore_js_1.normalizeInboundBindLabel)(newTitleTrim) : undefined;
+            const existingRecord = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, sessionId);
+            await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
+                version: 1,
+                sessionId,
+                agentId,
+                packName,
+                vscodeSessionResource: sessionResource.toString(),
+                chatMode: chatState.mode,
+                published: bindLabel
+                    ? {
+                        mode: "default",
+                        bindLabel,
+                        at: new Date().toISOString(),
+                    }
+                    : undefined,
+                gatewaySessionKeys: (0, gatewaySessionStore_js_1.mergeGatewaySessionKeyList)(existingRecord?.gatewaySessionKeys ?? [], params.sessionKey),
+                updatedAt: new Date().toISOString(),
+            });
+            await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, agentId, sessionId);
+            if (params.sessionKey) {
+                await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, agentId, params.sessionKey, sessionId);
+            }
+            for (const [id, entry] of this.sessionCache) {
+                if (entry.agentId === agentId) {
+                    this.sessionCache.delete(id);
+                }
+            }
+            this.sessionCache.set(sessionId, {
+                gatewaySessionKey: params.sessionKey ?? `__published__:${agentId}`,
+                agentId,
+                packName,
+                vscodeSessionResource: sessionResource,
+                chatSessionId: sessionId,
+                chatMode: chatState.mode,
+                lastActiveAt: Date.now(),
+            });
+            if (params.sessionKey) {
+                this.log(`Route index updated: ${params.sessionKey} -> ${sessionId}`);
+            }
+            if (params.initialMessage) {
+                await vscode.commands.executeCommand("workbench.action.chat.open", {
+                    mode: "agent",
+                    query: params.initialMessage,
+                    sessionResource: chatState.sessionResource,
+                });
+            }
+            vscode.window.showInformationMessage(`New chat session created from ${params.requestedBy ?? "Gateway"}`);
+            this.bridge?.respondSessionNew(requestId, {
+                success: true,
+                agentId,
+            });
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            this.log(`Failed to create new session: ${errorMsg}`);
+            this.bridge?.respondSessionNew(requestId, {
+                success: false,
+                error: errorMsg,
+            });
+        }
+    }
+    // ============================================================================
+    // Connection Lifecycle
+    // ============================================================================
+    async connect(opts) {
+        const silent = opts?.silent ?? false;
+        // Read merged settings here — onDidChangeConfiguration can lag behind await
+        // `getConfiguration().update()` from connectBridge / reset token, which would
+        // otherwise leave `this.config` stale and connect without a token.
+        const gwLive = vscode.workspace.getConfiguration("agentide.gateway");
+        const url = (gwLive.get("url") ?? "").trim() || (this.config.url ?? "").trim();
+        const tokenRaw = (gwLive.get("token") ?? "").trim() || (this.config.token ?? "").trim();
+        if (!url) {
+            if (!silent) {
+                vscode.window.showWarningMessage("Gateway URL not configured. Set agentide.gateway.url in settings.");
+            }
+            return;
+        }
+        if (this.isConnected) {
+            if (!silent) {
+                vscode.window.showInformationMessage("Already connected to Gateway");
+            }
+            return;
+        }
+        try {
+            this.updateStatusBar("connecting");
+            this.log("Connecting to Gateway...");
+            const options = {
+                gatewayUrl: url,
+                token: tokenRaw || undefined,
+                version: this.extensionContext.extension.packageJSON.version,
+                outputChannel: this.outputChannel,
+            };
+            this.bridge = new bridge_js_1.GatewayBridge(options);
+            this.bridge.on("connected", () => {
+                this.updateStatusBar("connected");
+                this.log("Connected to Gateway");
+                void this.registerConfiguredAgents();
+            });
+            this.bridge.on("disconnected", () => {
+                const sessionCount = this.sessionCache.size;
+                this.sessionCache.clear();
+                this.updateStatusBar("disconnected");
+                this.log(`Disconnected from Gateway. Cleared ${sessionCount} cached session(s).`);
+            });
+            this.bridge.on("error", (err) => {
+                this.log(`Gateway error: ${err.message}`);
+            });
+            this.bridge.on("reconnecting", (attempt) => {
+                this.updateStatusBar("reconnecting");
+                this.log(`Reconnecting... (attempt ${attempt})`);
+            });
+            this.bridge.on("agent.message", (data) => {
+                const rk = data.routeKey ?? data.sessionKey ?? "";
+                this.log(`Message for ${data.agentId}${rk ? ` (${rk})` : ""}: ${data.message.slice(0, 100)}...`);
+            });
+            this.bridge.on("agent.registered", (_agentId, result) => {
+                if (result?.needsBinding && this.onNeedsBinding) {
+                    this.onNeedsBinding(_agentId);
+                }
+            });
+            this.bridge.on("session.new.request", (request) => {
+                void this.handleSessionNewRequest(request);
+            });
+            this.bridge.on("agent.cancel", (params) => {
+                this.log(`Cancelling chat generation (agent.cancel: sessionKey=${params?.sessionKey})`);
+                const sessionKey = params?.sessionKey;
+                const agentId = params?.agentId;
+                if (sessionKey && agentId) {
+                    void this.openSessionForGatewayCancel(agentId, sessionKey);
+                    return;
+                }
+                void vscode.commands.executeCommand("workbench.action.chat.cancel");
+            });
+            await this.bridge.connect();
+            this.startHealthCheck();
+        }
+        catch (err) {
+            this.updateStatusBar("error");
+            const message = err instanceof Error ? err.message : String(err);
+            this.log(`Failed to connect: ${message}`);
+            if (!silent) {
+                vscode.window.showErrorMessage(`Failed to connect to Gateway: ${message}`);
+            }
+        }
+    }
+    async disconnect() {
+        this.stopHealthCheck();
+        if (!this.bridge) {
+            return;
+        }
+        try {
+            await this.bridge.disconnect();
+        }
+        finally {
+            this.sessionCache.clear();
+            this.bridge = null;
+            this.updateStatusBar("disconnected");
+        }
+    }
+    async openSessionForGatewayCancel(agentId, sessionKey) {
+        const routeKey = (0, bridge_js_1.buildIdeSessionRouteKey)(sessionKey, undefined) ?? sessionKey;
+        const cached = [...this.sessionCache.values()].find((e) => e.gatewaySessionKey === sessionKey);
+        if (cached) {
+            await vscode.commands.executeCommand("workbench.action.chat.open", {
+                sessionResource: cached.vscodeSessionResource.toString(),
+            });
+            await vscode.commands.executeCommand("workbench.action.chat.cancel");
+            return;
+        }
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        const sessionId = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId,
+            routeKey,
+            gatewaySessionKey: sessionKey,
+        }).then((r) => r.sessionId);
+        if (sessionId) {
+            const entry = await this.hydrateSessionEntryFromDisk(workspaceRoot, sessionId, agentId, "default");
+            if (entry) {
+                await vscode.commands.executeCommand("workbench.action.chat.open", {
+                    sessionResource: entry.vscodeSessionResource.toString(),
+                });
+                await vscode.commands.executeCommand("workbench.action.chat.cancel");
+                return;
+            }
+        }
+        await vscode.commands.executeCommand("workbench.action.chat.cancel");
+    }
+    // ============================================================================
+    // Health Check
+    // ============================================================================
+    startHealthCheck() {
+        this.stopHealthCheck();
+        this.healthCheckTimer = setInterval(() => {
+            void this.performHealthCheck();
+        }, GatewayService.HEALTH_CHECK_INTERVAL);
+    }
+    stopHealthCheck() {
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
+    }
+    async performHealthCheck() {
+        if (!this.bridge?.isConnected) {
+            return;
+        }
+        try {
+            await this.bridge.request("agents.list", {});
+        }
+        catch {
+            this.log("Health check failed, reconnecting...");
+            try {
+                await this.bridge.reconnect();
+            }
+            catch (err) {
+                this.log(`Reconnect failed: ${err}`);
+            }
+        }
+    }
+    // ============================================================================
+    // Status UI
+    // ============================================================================
+    showStatus() {
+        const connected = this.isConnected;
+        const agents = this.bridge?.registeredAgents ?? [];
+        const sessionCount = this.sessionCache.size;
+        let message = connected ? "Connected to Gateway" : "Disconnected from Gateway";
+        if (connected && agents.length > 0) {
+            message += `\nAgents: ${agents.join(", ")}`;
+        }
+        if (connected) {
+            message += `\nSessions: ${sessionCount} active (disk-backed routing)`;
+        }
+        if (connected && this.bridge?.connId) {
+            message += `\nConnection: ${this.bridge.connId}`;
+        }
+        vscode.window.showInformationMessage(message);
+    }
+    async showSessionMap() {
+        if (!this.isConnected) {
+            vscode.window.showInformationMessage("Not connected to Gateway");
+            return;
+        }
+        const items = [];
+        const workspaceRoot = this.resolveGatewayWorkspaceRoot();
+        const seenDefaults = new Set();
+        for (const agentId of this.bridge?.registeredAgents ?? []) {
+            const defaultId = await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, agentId);
+            if (defaultId && !seenDefaults.has(defaultId)) {
+                seenDefaults.add(defaultId);
+                const record = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, defaultId);
+                items.push({
+                    label: `$(pin) ${agentId}`,
+                    description: "default published session",
+                    detail: record?.published?.bindLabel
+                        ? `CLI: ${record.published.bindLabel} | ${defaultId}`
+                        : defaultId,
+                });
+            }
+        }
+        for (const entry of this.sessionCache.values()) {
+            const peerDisplay = entry.peerLabel ?? entry.gatewaySessionKey;
+            items.push({
+                label: `$(broadcast) ${peerDisplay}`,
+                description: `${entry.agentId}${entry.channel ? ` (${entry.channel})` : ""}`,
+                detail: `Pack: ${entry.packName} | ${entry.chatSessionId} | Active ${this.formatRelativeTime(entry.lastActiveAt)}`,
+            });
+        }
+        if (items.length === 0) {
+            vscode.window.showInformationMessage("No sessions mapped. Use 'Connect Chat to Gateway' to publish the current session.");
+            return;
+        }
+        await vscode.window.showQuickPick(items, {
+            title: `Gateway Sessions (${items.length})`,
+            placeHolder: "Session mappings (published + active routes)",
+        });
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    async queryChatState() {
+        return vscode.commands.executeCommand("agentide.getChatState");
+    }
+    formatRelativeTime(timestamp) {
+        const seconds = Math.floor((Date.now() - timestamp) / 1000);
+        if (seconds < 60) {
+            return "just now";
+        }
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) {
+            return `${minutes}m ago`;
+        }
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24) {
+            return `${hours}h ago`;
+        }
+        return `${Math.floor(hours / 24)}d ago`;
+    }
+    /**
+     * Status bar is now owned by GatewayLifecycleManager.
+     * This is a no-op kept for internal call-site compatibility.
+     */
+    updateStatusBar(_status) {
+        // No-op: lifecycle manager owns the single status bar icon
+    }
+    log(message) {
+        this.outputChannel.appendLine(`[${lifecycle_js_1.AGENT_ANYWHERE_LABEL}] ${message}`);
+    }
+    /** Callback invoked when a registered agent has no channel bindings. */
+    onNeedsBinding;
+    get isConnected() {
+        return this.bridge?.isConnected ?? false;
+    }
+    /**
+     * Send a gateway method request via the bridge's WebSocket client.
+     * Exposed via GatewayBridgeRef so the lifecycle manager can call gateway methods.
+     */
+    async request(method, params) {
+        if (!this.bridge?.isConnected) {
+            throw new Error("Not connected to gateway");
+        }
+        return this.bridge.request(method, params);
+    }
+    dispose() {
+        void this.disconnect();
+        for (const d of this.disposables) {
+            d.dispose();
+        }
+    }
+}
+exports.GatewayService = GatewayService;