@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/src/features/inbox/model/deleteTelegramInboxMessageTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteTelegramInboxMessageTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class DeleteTelegramInboxMessageTool {
+    inboxService;
+    constructor(inboxService) {
+        this.inboxService = inboxService;
+    }
+    register(server) {
+        server.registerTool("delete_telegram_inbox_message", {
+            title: "Delete Telegram Inbox Message",
+            description: "Use this only after you have fully processed an ordinary human Telegram inbox message. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. Delete the message so future inbox reads do not return it again.",
+            inputSchema: schema_1.deleteTelegramInboxMessageInputSchema,
+            outputSchema: schema_1.deleteTelegramInboxMessageOutputSchema,
+        }, async (args) => {
+            const output = await this.inboxService.deleteInboxMessage(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.DeleteTelegramInboxMessageTool = DeleteTelegramInboxMessageTool;

package/dist/services/features/telegram-mcp/src/features/inbox/model/getTelegramInboxCountTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetTelegramInboxCountTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class GetTelegramInboxCountTool {
+    inboxService;
+    constructor(inboxService) {
+        this.inboxService = inboxService;
+    }
+    register(server) {
+        server.registerTool("get_telegram_inbox_count", {
+            title: "Get Telegram Inbox Count",
+            description: "Use this to cheaply check whether ordinary human Telegram messages are waiting for the session. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. Do not use it for partner-note wakeups; partner notes must be read from .mcp-xchange/SHARED_INDEX.md instead.",
+            inputSchema: schema_1.getTelegramInboxCountInputSchema,
+            outputSchema: schema_1.getTelegramInboxCountOutputSchema,
+        }, async (args) => {
+            const output = await this.inboxService.getInboxCount(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.GetTelegramInboxCountTool = GetTelegramInboxCountTool;

package/dist/services/features/telegram-mcp/src/features/inbox/model/getTelegramInboxTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetTelegramInboxTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class GetTelegramInboxTool {
+    inboxService;
+    constructor(inboxService) {
+        this.inboxService = inboxService;
+    }
+    register(server) {
+        server.registerTool("get_telegram_inbox", {
+            title: "Get Telegram Inbox",
+            description: "Use this to read unsolicited Telegram inbox messages stored for the session. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. Each item now includes message_kind: human or system. Treat system messages as operational instructions from the service, not as normal user prompts. Returned items may also include local attachment paths from .mcp-xchange when the human message contained a photo or document. Do not use this first for partner-note wakeups; partner collaboration notes must be read from .mcp-xchange/SHARED_INDEX.md and the referenced note files.",
+            inputSchema: schema_1.getTelegramInboxInputSchema,
+            outputSchema: schema_1.getTelegramInboxOutputSchema,
+        }, async (args) => {
+            const output = await this.inboxService.getInbox(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.GetTelegramInboxTool = GetTelegramInboxTool;

package/dist/services/features/telegram-mcp/src/features/inbox/model/inboxService.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboxService = void 0;
+class InboxService {
+    config;
+    inboxStore;
+    _sessionStore;
+    logger;
+    projectIdentityResolver;
+    constructor(config, inboxStore, _sessionStore, logger, projectIdentityResolver) {
+        this.config = config;
+        this.inboxStore = inboxStore;
+        this._sessionStore = _sessionStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async getInboxCount(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const total = await this.inboxStore.countInboxMessages(resolved.sessionId);
+        this.logger.info("Telegram inbox count fetched", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            total,
+        });
+        return {
+            session_id: resolved.sessionId,
+            total,
+        };
+    }
+    async getInbox(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const limit = this.config.telegram.inboxBatchSize;
+        const messages = await this.inboxStore.listInboxMessages(resolved.sessionId, limit);
+        const total = await this.inboxStore.countInboxMessages(resolved.sessionId);
+        this.logger.info("Telegram inbox fetched", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            limit,
+            returned: messages.length,
+            total,
+        });
+        return {
+            session_id: resolved.sessionId,
+            total,
+            has_more: total > messages.length,
+            messages: messages.map((message) => ({
+                message_id: message.id,
+                source: "telegram",
+                message_kind: message.sourceTelegramMessageId > 0 ? "human" : "system",
+                telegram_chat_id: message.telegramChatId,
+                telegram_user_id: message.telegramUserId,
+                telegram_message_id: message.sourceTelegramMessageId,
+                text: message.text,
+                ...(message.attachments?.length
+                    ? { attachments: message.attachments }
+                    : {}),
+                received_at: message.receivedAt,
+            })),
+        };
+    }
+    async deleteInboxMessage(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const deleted = await this.inboxStore.deleteInboxMessage(resolved.sessionId, input.message_id);
+        this.logger.info("Telegram inbox message deleted", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            messageId: input.message_id,
+            deleted,
+        });
+        return {
+            deleted,
+            session_id: resolved.sessionId,
+            message_id: input.message_id,
+        };
+    }
+}
+exports.InboxService = InboxService;

package/dist/services/features/telegram-mcp/src/features/notify/model/notifyService.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotifyService = void 0;
+const redactSecrets_1 = require("../../../shared/lib/redact-secrets/redactSecrets");
+function mergeSavedContext(input, session) {
+    const savedSections = [];
+    if (input.use_saved_context && session?.summary) {
+        savedSections.push(session.summary);
+    }
+    if (input.use_saved_context && session?.files?.length) {
+        savedSections.push(`Known files:\n${session.files.map((file) => `- ${file}`).join("\n")}`);
+    }
+    if (input.use_saved_context && session?.decisions?.length) {
+        savedSections.push(`Known decisions:\n${session.decisions.map((item) => `- ${item}`).join("\n")}`);
+    }
+    if (input.use_saved_context && session?.risks?.length) {
+        savedSections.push(`Known risks:\n${session.risks.map((item) => `- ${item}`).join("\n")}`);
+    }
+    const mergedContext = [input.context, ...savedSections]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+    return {
+        ...(mergedContext ? { context: mergedContext } : {}),
+        ...(input.task
+            ? { task: input.task }
+            : session?.task
+                ? { task: session.task }
+                : {}),
+        ...(session?.label ? { sessionLabel: session.label } : {}),
+    };
+}
+class NotifyService {
+    _config;
+    sessionStore;
+    bindingStore;
+    transport;
+    logger;
+    projectIdentityResolver;
+    constructor(_config, sessionStore, bindingStore, transport, logger, projectIdentityResolver) {
+        this._config = _config;
+        this.sessionStore = sessionStore;
+        this.bindingStore = bindingStore;
+        this.transport = transport;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async send(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const binding = await this.bindingStore.getBinding(resolved.sessionId);
+        if (!binding) {
+            throw new Error("Session is not linked to Telegram. Call create_session_pair_code first.");
+        }
+        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const merged = mergeSavedContext(input, session);
+        this.logger.info("Telegram notification requested", {
+            sessionId: resolved.sessionId,
+            sessionLabel: resolved.sessionLabel,
+            sessionIdDerived: resolved.sessionIdDerived,
+            hasContext: Boolean(merged.context),
+            hasTask: Boolean(merged.task),
+        });
+        const sendResult = await this.transport.sendNotification({
+            sessionId: resolved.sessionId,
+            ...(merged.sessionLabel
+                ? { sessionLabel: merged.sessionLabel }
+                : resolved.sessionLabel
+                    ? { sessionLabel: resolved.sessionLabel }
+                    : {}),
+            recipient: {
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+            },
+            message: (0, redactSecrets_1.redactSecrets)(input.message),
+            ...(merged.task ? { task: (0, redactSecrets_1.redactSecrets)(merged.task) } : {}),
+            ...(merged.context ? { context: (0, redactSecrets_1.redactSecrets)(merged.context) } : {}),
+            ...(input.risk_level ? { riskLevel: input.risk_level } : {}),
+        });
+        this.logger.info("Telegram notification sent", {
+            sessionId: resolved.sessionId,
+            messageId: typeof sendResult.externalMessageId === "number"
+                ? sendResult.externalMessageId
+                : undefined,
+        });
+        return {
+            sent: true,
+            ...(typeof sendResult.externalMessageId === "number"
+                ? { message_id: sendResult.externalMessageId }
+                : {}),
+        };
+    }
+}
+exports.NotifyService = NotifyService;

package/dist/services/features/telegram-mcp/src/features/notify/model/notifyTelegramTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotifyTelegramTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class NotifyTelegramTool {
+    notifyService;
+    constructor(notifyService) {
+        this.notifyService = notifyService;
+    }
+    register(server) {
+        server.registerTool("notify_telegram", {
+            title: "Notify Telegram",
+            description: "Use this for one-way status or progress notifications to the human linked to the session. Pass session_id explicitly after pairing; do not rely on implicit defaults unless cwd is also correct for this agent workspace. This does not wait for a reply and does not create inbox work for the agent.",
+            inputSchema: schema_1.notifyTelegramInputSchema,
+            outputSchema: schema_1.notifyTelegramOutputSchema,
+        }, async (args) => {
+            const output = await this.notifyService.send(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.NotifyTelegramTool = NotifyTelegramTool;

package/dist/services/features/telegram-mcp/src/features/pair-session/model/clearSessionPairingTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClearSessionPairingTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class ClearSessionPairingTool {
+    pairSessionService;
+    constructor(pairSessionService) {
+        this.pairSessionService = pairSessionService;
+    }
+    register(server) {
+        server.registerTool("clear_session_pairing", {
+            title: "Clear Session Pairing",
+            description: "Use this when the user asks to unpair, unlink, detach, or reset Telegram binding for the current session. Remove Telegram binding for a session so it can be paired again.",
+            inputSchema: schema_1.clearSessionPairingInputSchema,
+            outputSchema: schema_1.clearSessionPairingOutputSchema,
+        }, async (args) => {
+            const output = await this.pairSessionService.clearPairing(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.ClearSessionPairingTool = ClearSessionPairingTool;

package/dist/services/features/telegram-mcp/src/features/pair-session/model/createSessionPairCodeTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSessionPairCodeTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class CreateSessionPairCodeTool {
+    pairSessionService;
+    constructor(pairSessionService) {
+        this.pairSessionService = pairSessionService;
+    }
+    register(server) {
+        server.registerTool("create_session_pair_code", {
+            title: "Create Session Pair Code",
+            description: "Use this when the user asks to link, pair, register, or connect the current agent/session to Telegram. Before calling it, determine the correct workspace cwd and, if tmux is available, collect current tmux attributes. Then create a short-lived Telegram pairing code for that session. After success, remember the returned session_id and pass it explicitly to later session-scoped tools.",
+            inputSchema: schema_1.createSessionPairCodeInputSchema,
+            outputSchema: schema_1.createSessionPairCodeOutputSchema,
+        }, async (args) => {
+            const output = await this.pairSessionService.createPairCode(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.CreateSessionPairCodeTool = CreateSessionPairCodeTool;

package/dist/services/features/telegram-mcp/src/features/pair-session/model/generatePairCode.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairSessionService = void 0;
+const ids_1 = require("../../../shared/lib/ids/ids");
+class PairSessionService {
+    config;
+    sessionStore;
+    bindingStore;
+    maintenanceStore;
+    logger;
+    projectIdentityResolver;
+    static MAX_PAIR_CODE_ATTEMPTS = 20;
+    constructor(config, sessionStore, bindingStore, maintenanceStore, logger, projectIdentityResolver) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.bindingStore = bindingStore;
+        this.maintenanceStore = maintenanceStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async unregisterGatewaySession(localSessionId) {
+        if (!this.config.distributed.gatewayPublicUrl) {
+            return;
+        }
+        const clientUuid = await this.maintenanceStore.getGatewayClientUuid();
+        if (!clientUuid) {
+            return;
+        }
+        const url = new URL(this.config.distributed.gatewayPublicUrl);
+        url.pathname = url.pathname.replace(/\/+$/u, "");
+        if (!url.pathname.endsWith("/gateway")) {
+            url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+        }
+        url.pathname = `${url.pathname}/sessions/unregister`.replace(/\/{2,}/gu, "/");
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(this.config.distributed.gatewayAuthToken
+                    ? { authorization: `Bearer ${this.config.distributed.gatewayAuthToken}` }
+                    : {}),
+            },
+            body: JSON.stringify({
+                client_uuid: clientUuid,
+                local_session_id: localSessionId,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Gateway session unregister failed with status ${response.status}: ${text || response.statusText}`);
+        }
+    }
+    async createPairCode(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const now = new Date();
+        const ttlSeconds = input.expires_in_seconds ?? this.config.pairCodeTtlSeconds;
+        const expiresAt = new Date(now.getTime() + ttlSeconds * 1000).toISOString();
+        let code = null;
+        const existingSession = await this.sessionStore.getSession(resolved.sessionId);
+        await this.sessionStore.setSession({
+            sessionId: resolved.sessionId,
+            ...(input.session_label
+                ? { label: input.session_label }
+                : resolved.sessionLabel
+                    ? { label: resolved.sessionLabel }
+                    : existingSession?.label
+                        ? { label: existingSession.label }
+                        : {}),
+            ...(input.cwd
+                ? { cwd: resolved.cwd }
+                : existingSession?.cwd
+                    ? { cwd: existingSession.cwd }
+                    : { cwd: resolved.cwd }),
+            ...(existingSession?.linkedSessionId
+                ? { linkedSessionId: existingSession.linkedSessionId }
+                : {}),
+            ...(existingSession?.activeProjectUuid
+                ? { activeProjectUuid: existingSession.activeProjectUuid }
+                : {}),
+            ...(existingSession?.activeProjectName
+                ? { activeProjectName: existingSession.activeProjectName }
+                : {}),
+            ...(existingSession?.task ? { task: existingSession.task } : {}),
+            ...(existingSession?.summary ? { summary: existingSession.summary } : {}),
+            ...(existingSession?.files ? { files: existingSession.files } : {}),
+            ...(existingSession?.decisions
+                ? { decisions: existingSession.decisions }
+                : {}),
+            ...(existingSession?.risks ? { risks: existingSession.risks } : {}),
+            ...(input.tmux_session_name
+                ? { tmuxSessionName: input.tmux_session_name }
+                : existingSession?.tmuxSessionName
+                    ? { tmuxSessionName: existingSession.tmuxSessionName }
+                    : {}),
+            ...(input.tmux_window_name
+                ? { tmuxWindowName: input.tmux_window_name }
+                : existingSession?.tmuxWindowName
+                    ? { tmuxWindowName: existingSession.tmuxWindowName }
+                    : {}),
+            ...(typeof input.tmux_window_index === "number"
+                ? { tmuxWindowIndex: input.tmux_window_index }
+                : typeof existingSession?.tmuxWindowIndex === "number"
+                    ? { tmuxWindowIndex: existingSession.tmuxWindowIndex }
+                    : {}),
+            ...(input.tmux_pane_id
+                ? { tmuxPaneId: input.tmux_pane_id, tmuxTarget: input.tmux_pane_id }
+                : existingSession?.tmuxPaneId
+                    ? {
+                        tmuxPaneId: existingSession.tmuxPaneId,
+                        ...(existingSession.tmuxTarget
+                            ? { tmuxTarget: existingSession.tmuxTarget }
+                            : {}),
+                    }
+                    : existingSession?.tmuxTarget
+                        ? { tmuxTarget: existingSession.tmuxTarget }
+                        : {}),
+            ...(typeof input.tmux_pane_index === "number"
+                ? { tmuxPaneIndex: input.tmux_pane_index }
+                : typeof existingSession?.tmuxPaneIndex === "number"
+                    ? { tmuxPaneIndex: existingSession.tmuxPaneIndex }
+                    : {}),
+            ...(existingSession?.lastTmuxNudgeAt
+                ? { lastTmuxNudgeAt: existingSession.lastTmuxNudgeAt }
+                : {}),
+            updatedAt: now.toISOString(),
+        });
+        this.projectIdentityResolver.persistSessionMarker({
+            cwd: resolved.cwd,
+            sessionId: resolved.sessionId,
+            sessionLabel: input.session_label?.trim() || resolved.sessionLabel,
+        });
+        for (let attempt = 0; attempt < PairSessionService.MAX_PAIR_CODE_ATTEMPTS; attempt += 1) {
+            const candidate = (0, ids_1.createPairCode)();
+            const record = {
+                code: candidate,
+                sessionId: resolved.sessionId,
+                ...(resolved.sessionLabel
+                    ? { sessionLabel: resolved.sessionLabel }
+                    : {}),
+                createdAt: now.toISOString(),
+                expiresAt,
+            };
+            const reserved = await this.bindingStore.createPairCode(record, ttlSeconds);
+            if (reserved) {
+                code = candidate;
+                break;
+            }
+        }
+        if (!code) {
+            throw new Error("Failed to reserve a unique 3-digit pairing code. Try again in a moment.");
+        }
+        this.logger.info("Session pair code created", {
+            sessionId: resolved.sessionId,
+            sessionLabel: resolved.sessionLabel,
+            sessionIdDerived: resolved.sessionIdDerived,
+            sessionLabelDerived: resolved.sessionLabelDerived,
+            cwd: input.cwd?.trim(),
+            tmuxSessionName: input.tmux_session_name,
+            tmuxWindowName: input.tmux_window_name,
+            tmuxWindowIndex: input.tmux_window_index,
+            tmuxPaneId: input.tmux_pane_id,
+            tmuxPaneIndex: input.tmux_pane_index,
+            expiresAt,
+            ttlSeconds,
+        });
+        return {
+            session_id: resolved.sessionId,
+            code,
+            expires_at: expiresAt,
+            status: "pending",
+            status_message: "Pairing code created. Send it to the Telegram bot and then use get_session_context to confirm that pairing is active.",
+            ...(this.config.telegram.botUsername
+                ? {
+                    telegram_link_hint: `https://t.me/${this.config.telegram.botUsername}?start=${encodeURIComponent(code)}`,
+                }
+                : {}),
+        };
+    }
+    async clearPairing(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const existingSession = await this.sessionStore.getSession(resolved.sessionId);
+        if (existingSession) {
+            await this.unregisterGatewaySession(resolved.sessionId);
+            await this.sessionStore.setSession({
+                ...existingSession,
+                activeProjectUuid: undefined,
+                activeProjectName: undefined,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        await this.bindingStore.clearBinding(resolved.sessionId);
+        this.logger.info("Session pairing cleared", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+        });
+        return {
+            cleared: true,
+            session_id: resolved.sessionId,
+        };
+    }
+}
+exports.PairSessionService = PairSessionService;

package/dist/services/features/telegram-mcp/src/features/session-context/model/clearSessionContextTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClearSessionContextTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class ClearSessionContextTool {
+    sessionContextService;
+    constructor(sessionContextService) {
+        this.sessionContextService = sessionContextService;
+    }
+    register(server) {
+        server.registerTool("clear_session_context", {
+            title: "Clear Session Context",
+            description: "Use this for full session cleanup/reset. It removes saved context, pairing, and related per-session state for the session.",
+            inputSchema: schema_1.clearSessionContextInputSchema,
+            outputSchema: schema_1.clearSessionContextOutputSchema,
+        }, async (args) => {
+            const output = await this.sessionContextService.clearContext(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.ClearSessionContextTool = ClearSessionContextTool;

package/dist/services/features/telegram-mcp/src/features/session-context/model/getSessionContextTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSessionContextTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class GetSessionContextTool {
+    sessionContextService;
+    constructor(sessionContextService) {
+        this.sessionContextService = sessionContextService;
+    }
+    register(server) {
+        server.registerTool("get_session_context", {
+            title: "Get Session Context",
+            description: "Debug/setup tool. Read the saved context and Telegram binding status for a session. Do not call this in the normal inbox-processing path after a tmux nudge unless you are diagnosing state.",
+            inputSchema: schema_1.getSessionContextInputSchema,
+            outputSchema: schema_1.getSessionContextOutputSchema,
+        }, async (args) => {
+            const output = await this.sessionContextService.getContext(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.GetSessionContextTool = GetSessionContextTool;