@deadragdoll/tellymcp 0.0.11 → 0.0.12

package/README-ru.md

@@ -272,6 +272,35 @@ tellymcp browser install
 
 Не подменяй browser workflow ad hoc shell-командами с Playwright, кроме случаев, когда ты отлаживаешь сам browser runtime.
 
+## Terminal Blockers
+
+Gateway prompt scanner теперь живёт от live-client lifecycle:
+
+- на старте gateway scanner только armed, но не крутится вхолостую
+- реальная работа начинается после подключения live client
+- relay console materialization идёт из `hello` и owner-route hydration, а не из `/menu`
+- детект работает по хвосту захваченного terminal buffer
+
+Основная эвристика blocker-а:
+
+- подряд идущие numbered choices: `1.`, `2.`, `3.`
+- рядом есть action hints вроде `press`, `input`, `choose`, `enter`, `esc`, `yes`, `no`
+- в Telegram notice попадают и 1-2 строки контекста выше menu block
+
+Когда blocker найден, gateway может отправить inline-кнопки:
+
+- `1..N`
+- `Enter`
+- `Esc`
+
+Эти кнопки отправляют в консоль ровно цифру или terminal action. Навигация маркером не используется.
+
+Операционные заметки:
+
+- одинаковый blocker fingerprint не перевысылается повторно
+- relay capture miss для offline agent считается debug-only шумом
+- `Storage` и `Screenshots` на gateway теперь relay-aware и читают metadata через gateway routes, а не через filesystem самого gateway
+
 ## Collaboration
 
 Проекты:

package/README.md

@@ -272,6 +272,34 @@ tellymcp browser install
 
 Do not replace browser workflows with ad hoc shell Playwright commands unless you are debugging the runtime itself.
 
+## Terminal Blockers
+
+Gateway prompt scanning is now live-client driven:
+
+- the scanner is armed on gateway startup but starts working only after a live client connects
+- relay console materialization happens from gateway hello/owner-route hydration, not from `/menu`
+- prompt detection works on the tail of the captured terminal buffer
+
+Primary blocker heuristic:
+
+- contiguous numbered choices like `1.`, `2.`, `3.`
+- nearby action hints such as `press`, `input`, `choose`, `enter`, `esc`, `yes`, `no`
+- optional context lines above the menu block are included in the Telegram notice
+
+When a blocker is detected, the gateway can send inline Telegram buttons for:
+
+- `1..N`
+- `Enter`
+- `Esc`
+
+Those buttons send exactly the digit or terminal action to the target console. No marker navigation is used.
+
+Operational notes:
+
+- repeated scans of the same blocker fingerprint do not resend the notice
+- relay capture misses for offline agents are treated as debug-only noise
+- `Storage` and `Screenshots` on the gateway are relay-aware and read console metadata through gateway routes instead of the gateway filesystem
+
 ## Collaboration Model
 
 Projects:

package/TOOLS.md

@@ -38,6 +38,21 @@ Browser runtime rule:
 - If browser tools fail because the Playwright browser runtime is missing, install it with `tellymcp browser install`.
 - Do not stop at the installation error itself. Install the browser runtime first, then retry the browser tool.
 
+Terminal prompt scan rules:
+
+- gateway prompt scan is driven by live client lifecycle, not by manual menu entry
+- the scanner works on the tail of the captured terminal buffer
+- the main blocker signal is:
+  - a contiguous numbered choice block like `1.`, `2.`, `3.`
+  - nearby action-hint language such as `press`, `input`, `choose`, `enter`, `esc`, `yes`, `no`
+- exact footer text is helpful but not required
+- when a blocker notice contains inline buttons, those buttons intentionally send only:
+  - a digit `1..N`
+  - `Enter`
+  - `Esc`
+- do not assume marker navigation
+- do not reinterpret those buttons as alternate hotkeys like `(y)` or `(p)`
+
 Collaboration tools:
 
 - `list_gateway_sessions`
@@ -725,6 +740,8 @@ Input:
 
 - `session_id?`
 - `url`
+- `width?`
+- `height?`
 - `wait_until?`
 - `reset_context?`
 
@@ -735,12 +752,19 @@ Output:
 - `created_context`
 - `url`
 - `title?`
+- `viewport_width?`
+- `viewport_height?`
 
 Notes:
 
 - each session gets its own isolated browser context and page
 - call this first before reading console, DOM, styles, or screenshots
 - `url` may be an absolute URL, or a relative path when `BROWSER_ADDRESS` is configured
+- in headed mode the browser window is started maximized by default
+- in headed mode a fresh browser context is created without a fixed viewport unless you explicitly pass `width` and `height`
+- if you want page content to grow and shrink together with the outer browser window, do not pass `width` and `height`
+- if you pass viewport size, pass both `width` and `height` together
+- use explicit `width` and `height` when the task depends on a specific responsive breakpoint or working area
 
 ## `browser_console`
 
@@ -1083,6 +1107,8 @@ Telegram UI summary:
 - default logical console identity comes from `.mcpsession.json` in the workspace or explicit `-s`
 - terminal runtime metadata does not change `session_id`
 - `Browser -> Screenshots` lists screenshots created by `browser_screenshot`
+- `Storage` and `Screenshots` are relay-aware on the gateway
+- for relay consoles they read file metadata through gateway routes, not through the gateway filesystem
 - `Storage` browses `.mcp-xchange` for the active console and can send stored notes/files back into Telegram
 - `Settings` contains `Info`, `Rename`, `Unpair`, `Back`
 - project/collab work is the only supported user-facing collaboration path in Telegram UI

package/VERSION.md

@@ -100,8 +100,8 @@ For detailed engineering history, refactors, and internal development notes, see
   - `tellymcp doctor`
   - `tellymcp mcp --help`
 - Standalone and public installation guides:
-  - [STANDALONE.md](STANDALONE.md)
-  - [STANDALONE-ru.md](STANDALONE-ru.md)
+  - [STANDALONE.md](docs/STANDALONE.md)
+  - [STANDALONE-ru.md](docs/STANDALONE-ru.md)
 - Browser runtime helper:
   - `tellymcp browser install`
 - Public README set for GitHub and npm:

package/dist/services/features/telegram-mcp/gateway-socket.service.js

@@ -1226,6 +1226,13 @@ const TelegramMcpGatewaySocketService = {
                             }))
                             : [],
                     }, { meta: { internal_call: true } });
+                    await runtime.telegramTransport.hydrateGatewayClientOwnerRoute({
+                        clientUuid: hello.client_uuid,
+                        ...(hello.gateway_user_uuid
+                            ? { gatewayUserUuid: hello.gateway_user_uuid }
+                            : {}),
+                    });
+                    runtime.telegramTransport.ensurePromptScanRunning();
                 }
                 const localVersionInfo = this.getLocalVersionInfo?.() ?? {
                     packageVersion: "0.0.0-unknown",
@@ -2002,6 +2009,9 @@ const TelegramMcpGatewaySocketService = {
                             }
                         }
                     }
+                    if ((this.connectedClientsByUuid?.size ?? 0) === 0) {
+                        runtime.telegramTransport.pausePromptScan();
+                    }
                     this.connectedClientToolsAlerts?.delete(socket);
                     this.connectedClients?.delete(socket);
                     runtime.logger.warn("Gateway WS client disconnected", {

package/dist/services/features/telegram-mcp/src/entities/request/model/schema.js

@@ -194,6 +194,8 @@ exports.clearSessionContextOutputSchema = z.object({
 exports.browserOpenInputSchema = z.object({
     session_id: z.string().trim().min(1).optional(),
     url: z.string().trim().min(1),
+    width: z.number().int().positive().max(10000).optional(),
+    height: z.number().int().positive().max(10000).optional(),
     wait_until: z
         .enum(["load", "domcontentloaded", "networkidle", "commit"])
         .optional(),
@@ -205,6 +207,8 @@ exports.browserOpenOutputSchema = z.object({
     created_context: z.boolean(),
     url: z.string().url(),
     title: z.string().optional(),
+    viewport_width: z.number().int().positive().optional(),
+    viewport_height: z.number().int().positive().optional(),
 });
 exports.browserReloadInputSchema = z.object({
     session_id: z.string().trim().min(1).optional(),

package/dist/services/features/telegram-mcp/src/features/browser/model/browserOpenTool.js

@@ -18,7 +18,7 @@ class BrowserOpenTool {
     register(server) {
         server.registerTool("browser_open", {
             title: "Browser Open",
-            description: "Open a URL in the isolated Playwright browser context for the current session. Reuse the existing tab unless reset_context=true.",
+            description: "Open a URL in the isolated Playwright browser context for the current session. Reuse the existing tab unless reset_context=true. Optionally pass width and height to control the viewport.",
             inputSchema: schema_1.browserOpenInputSchema,
             outputSchema: schema_1.browserOpenOutputSchema,
         }, async (args) => {

package/dist/services/features/telegram-mcp/src/features/browser/model/browserService.js

@@ -47,6 +47,8 @@ function formatConsoleLocation(message) {
 function escapeCssAttributeValue(value) {
     return value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
 }
+const DEFAULT_BROWSER_VIEWPORT_WIDTH = 1720;
+const DEFAULT_BROWSER_VIEWPORT_HEIGHT = 980;
 class BrowserService {
     config;
     sessionStore;
@@ -85,12 +87,26 @@ class BrowserService {
         }
         this.ensureEnabled();
         const existingState = this.sessionStates.get(normalizedSessionId);
-        const shouldReset = input.reset_context === true;
+        const requestedViewport = this.resolveRequestedViewport(input);
+        const shouldUpgradeLegacyViewport = this.config.browser.headless === false &&
+            input.reset_context !== true &&
+            !requestedViewport &&
+            Boolean(existingState?.page.viewportSize());
+        const shouldReset = input.reset_context === true || shouldUpgradeLegacyViewport;
         const targetUrl = this.resolveBrowserUrl(input.url);
         if (shouldReset && existingState) {
             await this.closeState(normalizedSessionId, existingState);
         }
-        const { state, createdContext } = await this.ensureSessionState(normalizedSessionId, shouldReset);
+        const { state, createdContext } = await this.ensureSessionState(normalizedSessionId, shouldReset, input);
+        if (requestedViewport) {
+            await state.page.setViewportSize(requestedViewport);
+        }
+        else if (this.config.browser.headless !== false) {
+            await state.page.setViewportSize({
+                width: DEFAULT_BROWSER_VIEWPORT_WIDTH,
+                height: DEFAULT_BROWSER_VIEWPORT_HEIGHT,
+            });
+        }
         const waitUntil = (input.wait_until ??
             this.config.browser.waitUntil);
         await state.page.goto(targetUrl, {
@@ -108,13 +124,18 @@ class BrowserService {
             createdContext,
             waitUntil,
             headless: this.config.browser.headless,
+            viewportWidth: state.page.viewportSize()?.width ?? requestedViewport?.width,
+            viewportHeight: state.page.viewportSize()?.height ?? requestedViewport?.height,
         });
+        const viewport = state.page.viewportSize();
         return {
             session_id: normalizedSessionId,
             opened: true,
             created_context: createdContext,
             url: state.currentUrl,
             ...(state.title ? { title: state.title } : {}),
+            ...(viewport?.width ? { viewport_width: viewport.width } : {}),
+            ...(viewport?.height ? { viewport_height: viewport.height } : {}),
         };
     }
     async getConsole(input) {
@@ -690,10 +711,13 @@ class BrowserService {
     async ensureBrowser() {
         this.browserPromise ??= (async () => {
             const playwright = await this.ensurePlaywright();
-            const launchArgs = this.config.browser.headless === false &&
-                this.config.browser.devtools === true
-                ? ["--auto-open-devtools-for-tabs"]
-                : [];
+            const launchArgs = [];
+            if (this.config.browser.headless === false) {
+                launchArgs.push("--start-maximized");
+                if (this.config.browser.devtools === true) {
+                    launchArgs.push("--auto-open-devtools-for-tabs");
+                }
+            }
             const browser = await playwright.chromium.launch({
                 headless: this.config.browser.headless,
                 slowMo: this.config.browser.slowMoMs,
@@ -717,13 +741,13 @@ class BrowserService {
         })();
         return this.browserPromise;
     }
-    async ensureSessionState(sessionId, forceNewContext) {
+    async ensureSessionState(sessionId, forceNewContext, openInput) {
         const existing = this.sessionStates.get(sessionId);
         if (existing && !forceNewContext) {
             return { state: existing, createdContext: false };
         }
         const browser = await this.ensureBrowser();
-        const context = await browser.newContext();
+        const context = await browser.newContext(this.buildContextOptions(openInput));
         const page = await context.newPage();
         const createdAt = new Date().toISOString();
         const state = {
@@ -763,6 +787,32 @@ class BrowserService {
         this.sessionStates.set(sessionId, state);
         return { state, createdContext: true };
     }
+    resolveRequestedViewport(input) {
+        const width = input?.width;
+        const height = input?.height;
+        if (!width && !height) {
+            return null;
+        }
+        if (!width || !height) {
+            throw new Error("Browser viewport requires both width and height together.");
+        }
+        return { width, height };
+    }
+    buildContextOptions(input) {
+        const requestedViewport = this.resolveRequestedViewport(input);
+        if (requestedViewport) {
+            return {
+                viewport: requestedViewport,
+                screen: requestedViewport,
+            };
+        }
+        if (this.config.browser.headless === false) {
+            return {
+                viewport: null,
+            };
+        }
+        return {};
+    }
     recordNetworkFailure(state, request, response) {
         const failure = request.failure();
         pushBounded(state.networkFailures, {

package/dist/services/features/telegram-mcp/src/features/distributed-gateway/model/gatewayHttpService.js

@@ -676,6 +676,54 @@ class GatewayHttpService {
                 return true;
             }
         }
+        if (pathname === "/gateway/live/action") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const sessionId = typeof body.session_id === "string" ? body.session_id.trim() : "";
+                const action = typeof body.action === "string" ? body.action.trim() : "";
+                const text = typeof body.text === "string" ? body.text : "";
+                const relayTarget = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+                if (!relayTarget) {
+                    writeJson(res, 400, {
+                        error: "relay session_id is required",
+                    });
+                    return true;
+                }
+                if (!["enter", "escape", "text"].includes(action)) {
+                    writeJson(res, 400, {
+                        error: "action must be one of: enter, escape, text",
+                    });
+                    return true;
+                }
+                if (action === "text" && (!text || text.length > 16)) {
+                    writeJson(res, 400, {
+                        error: "text payload is required and must be <= 16 characters",
+                    });
+                    return true;
+                }
+                await this.requestLiveRelayAction({
+                    clientUuid: relayTarget.clientUuid,
+                    localSessionId: relayTarget.localSessionId,
+                    action: action,
+                    ...(action === "text" ? { text } : {}),
+                });
+                writeJson(res, 200, { ok: true });
+                return true;
+            }
+            catch (error) {
+                console.error("Gateway live action request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
         if (pathname === "/gateway/client/register") {
             if (req.method !== "POST") {
                 writeText(res, 405, "Method not allowed");

package/dist/services/features/telegram-mcp/src/shared/i18n/resources/en.js

@@ -396,11 +396,15 @@ exports.enMenu = {
             unavailable_target: "terminal target: {{terminalTarget}}",
             unavailable_reason: "This usually means the terminal runtime is not running or is unreachable for the current target.",
             unavailable_action: "Restart the terminal runtime for this console, or update/remove the terminal target for this session.",
-            prompt_detected_title: "🛎 The agent in session {{sessionName}} may be waiting for your input.",
+            prompt_detected_title: "🛎 Possible blocker in {{sessionName}}",
             prompt_detected_score: "Detection score: {{score}}",
             prompt_detected_target: "terminal target: {{terminalTarget}}",
             prompt_detected_hint: "Open Live or answer in the terminal if this prompt really needs you.",
             prompt_detected_excerpt: "Recent prompt lines:",
+            prompt_action_sent: "Sent {{action}} to terminal.",
+            prompt_action_stale: "This blocker action is no longer available.",
+            prompt_action_failed: "Failed to send the action to terminal.",
+            prompt_action_invalid: "Invalid blocker action.",
         },
     },
     admin: {

package/dist/services/features/telegram-mcp/src/shared/i18n/resources/ru.js

@@ -396,11 +396,15 @@ exports.ruMenu = {
             unavailable_target: "terminal target: {{terminalTarget}}",
             unavailable_reason: "Обычно это значит, что терминальный runtime не запущен или недоступен для текущего target.",
             unavailable_action: "Перезапусти терминальный runtime для этой консоли или обнови/сними terminal target для этой сессии.",
-            prompt_detected_title: "🛎 Похоже, агент в сессии {{sessionName}} ждёт твой ввод.",
+            prompt_detected_title: "🛎 Возможный блокер в {{sessionName}}",
             prompt_detected_score: "Сила срабатывания: {{score}}",
             prompt_detected_target: "terminal target: {{terminalTarget}}",
             prompt_detected_hint: "Открой Live или ответь в терминале, если этот prompt действительно требует тебя.",
             prompt_detected_excerpt: "Последние строки prompt:",
+            prompt_action_sent: "Отправил {{action}} в терминал.",
+            prompt_action_stale: "Это действие для блокера уже недоступно.",
+            prompt_action_failed: "Не удалось отправить действие в терминал.",
+            prompt_action_invalid: "Некорректное действие блокера.",
         },
     },
     admin: {

package/dist/services/features/telegram-mcp/src/shared/integrations/redis/stateStore.js

@@ -26,6 +26,9 @@ function principalActiveSessionKey(principal) {
 function principalActiveSessionMatchPattern(telegramUserId) {
     return `${KEY_PREFIX}:principal:*:${telegramUserId}:active-session`;
 }
+function bindingMatchPattern() {
+    return `${KEY_PREFIX}:binding:*`;
+}
 function menuPayloadKey(key) {
     return `${KEY_PREFIX}:menu-payload:${key}`;
 }
@@ -204,6 +207,31 @@ class RedisStateStore {
     async listBoundSessionIdsForPrincipal(principal) {
         return this.redis.smembers(principalSessionsKey(principal));
     }
+    async listBoundPrincipals() {
+        const principals = new Map();
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", bindingMatchPattern(), "COUNT", 100);
+            cursor = nextCursor;
+            for (const key of keys) {
+                const raw = await this.redis.get(key);
+                const binding = parseJson(raw);
+                if (!binding) {
+                    continue;
+                }
+                const telegramChatId = Number(binding.telegramChatId);
+                const telegramUserId = Number(binding.telegramUserId);
+                if (!Number.isFinite(telegramChatId) || !Number.isFinite(telegramUserId)) {
+                    continue;
+                }
+                principals.set(`${telegramChatId}:${telegramUserId}`, {
+                    telegramChatId,
+                    telegramUserId,
+                });
+            }
+        } while (cursor !== "0");
+        return Array.from(principals.values());
+    }
     async resetRuntimeState() {
         await this.redis.del(activeRequestKey());
         await this.redis.del(queueKey());

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transport.js

@@ -43,6 +43,7 @@ class TelegramTransport {
     lifecycleActions;
     attachmentStore;
     broadcastActions;
+    consoleRegistry;
     context;
     documentActions;
     eventActions;
@@ -185,6 +186,7 @@ class TelegramTransport {
         this.lifecycleActions = composition.lifecycleActions;
         this.attachmentStore = composition.attachmentStore;
         this.broadcastActions = composition.broadcastActions;
+        this.consoleRegistry = composition.consoleRegistry;
         this.context = composition.context;
         this.documentActions = composition.documentActions;
         this.eventActions = composition.eventActions;
@@ -436,9 +438,44 @@ class TelegramTransport {
     async sendStartupNotifications() {
         await this.lifecycleActions.sendStartupNotifications(__dirname);
     }
+    ensurePromptScanRunning() {
+        this.terminalRuntime.ensurePromptScanRunning();
+    }
+    pausePromptScan() {
+        this.terminalRuntime.pausePromptScan();
+    }
     async sendAdminGatewayRegistrationNotifications(input) {
         await this.requestFlow.sendAdminGatewayRegistrationNotifications(input);
     }
+    async hydrateGatewayClientOwnerRoute(input) {
+        if (this.config.distributed.mode !== "gateway") {
+            return;
+        }
+        const route = await this.callGatewayJson("/user/route", {
+            client_uuid: input.clientUuid,
+            ...(input.gatewayUserUuid ? { gateway_user_uuid: input.gatewayUserUuid } : {}),
+        });
+        if (typeof route.telegram_user_id !== "number" ||
+            typeof route.telegram_chat_id !== "number") {
+            this.logger.debug("Skipping gateway owner route hydration because Telegram route is unavailable", {
+                clientUuid: input.clientUuid,
+                gatewayUserUuid: input.gatewayUserUuid ?? null,
+            });
+            return;
+        }
+        await this.consoleRegistry.ensureScopedConsolesBound({
+            principal: {
+                telegramChatId: route.telegram_chat_id,
+                telegramUserId: route.telegram_user_id,
+            },
+        });
+        this.logger.info("Gateway owner route hydrated for live client", {
+            clientUuid: input.clientUuid,
+            gatewayUserUuid: input.gatewayUserUuid ?? null,
+            telegramChatId: route.telegram_chat_id,
+            telegramUserId: route.telegram_user_id,
+        });
+    }
     async sendRequest(input) {
         return this.requestFlow.sendRequest(input);
     }

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportConsoleRegistry.js

@@ -53,12 +53,18 @@ class TransportConsoleRegistry {
         for (const consoleSession of consoles) {
             const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(consoleSession.client_uuid, consoleSession.local_session_id);
             relaySessionIds.push(relaySessionId);
-            await this.materializeRelaySession({
-                ctx: input.ctx,
-                principal: input.principal,
-                relaySessionId,
-                consoleSession,
-            });
+            await this.materializeRelaySession(input.ctx
+                ? {
+                    ctx: input.ctx,
+                    principal: input.principal,
+                    relaySessionId,
+                    consoleSession,
+                }
+                : {
+                    principal: input.principal,
+                    relaySessionId,
+                    consoleSession,
+                });
         }
         const existingActive = await this.host.bindingStore.getActiveSessionIdForPrincipal(input.principal);
         const nextBound = new Set(await this.host.bindingStore.listBoundSessionIdsForPrincipal(input.principal));
@@ -119,7 +125,7 @@ class TransportConsoleRegistry {
             sessionId: input.relaySessionId,
             telegramChatId: input.principal.telegramChatId,
             telegramUserId: input.principal.telegramUserId,
-            ...(input.ctx.from?.username
+            ...(input.ctx?.from?.username
                 ? { telegramUsername: input.ctx.from.username }
                 : {}),
             linkedAt: new Date().toISOString(),

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportConstructorWiring.js

@@ -92,6 +92,11 @@ function buildTransportConstructorWiring(host) {
         resolveLocaleForTelegramUserId: (userId) => context.resolveLocaleForTelegramUserId(userId),
         sendNotification: (input) => requestFlow.sendNotification(input),
         sendLiveViewLauncherMessage: (input) => liveActions.sendLauncherMessage(input),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+        createTerminalPromptActionPayload: (sessionId, actions) => payloadState.createTerminalPromptActionPayload(sessionId, actions),
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        sendChatMessage: (telegramChatId, text, options, meta) => outputActions.sendChatMessage(telegramChatId, text, options, meta),
         t: (locale, key, vars) => context.t(locale, key, vars),
     });
     const terminalRuntime = new transportTerminalRuntime_1.TransportTerminalRuntime({
@@ -103,6 +108,9 @@ function buildTransportConstructorWiring(host) {
         isTelegramEnabled: () => host.config.distributed.mode !== "client" && Boolean(host.config.telegram.botToken?.trim()),
         terminalActions,
         terminalNudgeDebounceTimers: host.terminalNudgeDebounceTimers,
+        ensureGatewayScopedConsolesBoundForPrincipal: async (principal) => {
+            await consoleRegistry.ensureScopedConsolesBound({ principal });
+        },
     });
     const menuFingerprints = new transportMenuFingerprints_1.TransportMenuFingerprints({
         logger: host.logger,
@@ -560,6 +568,7 @@ function buildTransportConstructorWiring(host) {
         handleProjectMemberNoteCallback: (ctx) => projectActions.handleProjectMemberNoteCallback(ctx),
         handleProjectMemberLiveCallback: (ctx) => projectActions.handleProjectMemberLiveCallback(ctx),
         handleLiveApprovalCallback: (ctx) => projectActions.handleLiveApprovalCallback(ctx),
+        handleTerminalPromptActionCallback: (ctx) => terminalActions.handlePromptActionCallback(ctx),
         handleProjectDetailCallback: (ctx) => projectActions.handleProjectDetailCallback(ctx),
         handleProjectDeleteCallback: (ctx) => projectActions.handleProjectDeleteCallback(ctx),
         handleProjectLeaveCallback: (ctx) => projectActions.handleProjectLeaveCallback(ctx),

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportMenuShell.js

@@ -41,6 +41,9 @@ class TransportMenuShell {
         bot.callbackQuery(/^live-approval:(approve|deny):(.+)$/u, async (ctx) => {
             await this.host.handleLiveApprovalCallback(ctx);
         });
+        bot.callbackQuery(/^terminal-prompt-action:(\d+|enter|escape):(.+)$/u, async (ctx) => {
+            await this.host.handleTerminalPromptActionCallback(ctx);
+        });
         bot.callbackQuery(/^project-detail:(.+)$/u, async (ctx) => {
             await this.host.handleProjectDetailCallback(ctx);
         });

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportPayloadState.js

@@ -77,6 +77,13 @@ class TransportPayloadState {
             ...(input.projectName ? { projectName: input.projectName } : {}),
         });
     }
+    async createTerminalPromptActionPayload(sessionId, actions) {
+        return this.createPayload({
+            kind: "terminal-prompt-action",
+            sessionId,
+            promptActions: actions,
+        });
+    }
     async createPartnerFileTargetPayload(sessionId, targetSessionId, title, filePath) {
         return this.createPayload({
             kind: "partner-file-target",