@deadragdoll/tellymcp 0.0.1

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetTmuxTargetTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class GetTmuxTargetTool {
+    sessionContextService;
+    constructor(sessionContextService) {
+        this.sessionContextService = sessionContextService;
+    }
+    register(server) {
+        server.registerTool("get_tmux_target", {
+            title: "Get tmux Target",
+            description: "Debug/setup tool. Return the stored tmux pane target for a session, including the last time the service nudged that tmux pane. Do not call this in the normal inbox-processing path after a tmux nudge.",
+            inputSchema: schema_1.getTmuxTargetInputSchema,
+            outputSchema: schema_1.getTmuxTargetOutputSchema,
+        }, async (args) => {
+            const output = await this.sessionContextService.getTmuxTarget(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.GetTmuxTargetTool = GetTmuxTargetTool;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenameSessionTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class RenameSessionTool {
+    sessionContextService;
+    constructor(sessionContextService) {
+        this.sessionContextService = sessionContextService;
+    }
+    register(server) {
+        server.registerTool("rename_session", {
+            title: "Rename Session",
+            description: "Rename only the human-readable session label. Use this when the user wants a clearer session name; it does not change session_id, pairing, tmux target, or saved context.",
+            inputSchema: schema_1.renameSessionInputSchema,
+            outputSchema: schema_1.renameSessionOutputSchema,
+        }, async (args) => {
+            const output = await this.sessionContextService.renameSession(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.RenameSessionTool = RenameSessionTool;

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

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionContextService = void 0;
+const redactSecrets_1 = require("../../../shared/lib/redact-secrets/redactSecrets");
+class SessionContextService {
+    sessionStore;
+    bindingStore;
+    logger;
+    projectIdentityResolver;
+    constructor(sessionStore, bindingStore, logger, projectIdentityResolver) {
+        this.sessionStore = sessionStore;
+        this.bindingStore = bindingStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async setContext(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const updatedAt = new Date().toISOString();
+        const existing = await this.sessionStore.getSession(resolved.sessionId);
+        const binding = await this.bindingStore.getBinding(resolved.sessionId);
+        await this.sessionStore.setSession({
+            sessionId: resolved.sessionId,
+            ...(input.session_label
+                ? { label: (0, redactSecrets_1.redactSecrets)(input.session_label) }
+                : resolved.sessionLabel
+                    ? { label: (0, redactSecrets_1.redactSecrets)(resolved.sessionLabel) }
+                    : existing?.label
+                        ? { label: existing.label }
+                        : {}),
+            ...(existing?.cwd ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
+            ...(existing?.linkedSessionId
+                ? { linkedSessionId: existing.linkedSessionId }
+                : {}),
+            ...(existing?.activeProjectUuid
+                ? { activeProjectUuid: existing.activeProjectUuid }
+                : {}),
+            ...(existing?.activeProjectName
+                ? { activeProjectName: existing.activeProjectName }
+                : {}),
+            ...(input.task
+                ? { task: (0, redactSecrets_1.redactSecrets)(input.task) }
+                : existing?.task
+                    ? { task: existing.task }
+                    : {}),
+            summary: (0, redactSecrets_1.redactSecrets)(input.summary),
+            ...(input.files?.length
+                ? { files: input.files.map((item) => (0, redactSecrets_1.redactSecrets)(item)) }
+                : existing?.files
+                    ? { files: existing.files }
+                    : {}),
+            ...(input.decisions?.length
+                ? { decisions: input.decisions.map((item) => (0, redactSecrets_1.redactSecrets)(item)) }
+                : existing?.decisions
+                    ? { decisions: existing.decisions }
+                    : {}),
+            ...(input.risks?.length
+                ? { risks: input.risks.map((item) => (0, redactSecrets_1.redactSecrets)(item)) }
+                : existing?.risks
+                    ? { risks: existing.risks }
+                    : {}),
+            ...(existing?.tmuxSessionName
+                ? { tmuxSessionName: existing.tmuxSessionName }
+                : {}),
+            ...(existing?.tmuxWindowName
+                ? { tmuxWindowName: existing.tmuxWindowName }
+                : {}),
+            ...(typeof existing?.tmuxWindowIndex === "number"
+                ? { tmuxWindowIndex: existing.tmuxWindowIndex }
+                : {}),
+            ...(existing?.tmuxPaneId ? { tmuxPaneId: existing.tmuxPaneId } : {}),
+            ...(typeof existing?.tmuxPaneIndex === "number"
+                ? { tmuxPaneIndex: existing.tmuxPaneIndex }
+                : {}),
+            ...(existing?.tmuxTarget ? { tmuxTarget: existing.tmuxTarget } : {}),
+            ...(existing?.lastTmuxNudgeAt
+                ? { lastTmuxNudgeAt: existing.lastTmuxNudgeAt }
+                : {}),
+            ...(existing?.lastSeenToolsHash
+                ? { lastSeenToolsHash: existing.lastSeenToolsHash }
+                : {}),
+            ...(existing?.lastNotifiedToolsHash
+                ? { lastNotifiedToolsHash: existing.lastNotifiedToolsHash }
+                : {}),
+            updatedAt,
+        });
+        this.projectIdentityResolver.persistSessionMarker({
+            cwd: resolved.cwd,
+            sessionId: resolved.sessionId,
+            sessionLabel: input.session_label?.trim() || resolved.sessionLabel,
+        });
+        this.logger.info("Session context saved", {
+            sessionId: resolved.sessionId,
+            sessionLabel: resolved.sessionLabel,
+            sessionIdDerived: resolved.sessionIdDerived,
+            sessionLabelDerived: resolved.sessionLabelDerived,
+            hasBinding: Boolean(binding),
+            fileCount: input.files?.length ?? 0,
+            decisionCount: input.decisions?.length ?? 0,
+            riskCount: input.risks?.length ?? 0,
+        });
+        return {
+            saved: true,
+            session_id: resolved.sessionId,
+            updated_at: updatedAt,
+            has_binding: Boolean(binding),
+        };
+    }
+    async renameSession(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const existing = await this.sessionStore.getSession(resolved.sessionId);
+        const updatedAt = new Date().toISOString();
+        const label = (0, redactSecrets_1.redactSecrets)(input.title);
+        await this.sessionStore.setSession({
+            sessionId: resolved.sessionId,
+            label,
+            ...(existing?.cwd ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
+            ...(existing?.linkedSessionId
+                ? { linkedSessionId: existing.linkedSessionId }
+                : {}),
+            ...(existing?.activeProjectUuid
+                ? { activeProjectUuid: existing.activeProjectUuid }
+                : {}),
+            ...(existing?.activeProjectName
+                ? { activeProjectName: existing.activeProjectName }
+                : {}),
+            ...(existing?.task ? { task: existing.task } : {}),
+            ...(existing?.summary ? { summary: existing.summary } : {}),
+            ...(existing?.files ? { files: existing.files } : {}),
+            ...(existing?.decisions ? { decisions: existing.decisions } : {}),
+            ...(existing?.risks ? { risks: existing.risks } : {}),
+            ...(existing?.tmuxSessionName
+                ? { tmuxSessionName: existing.tmuxSessionName }
+                : {}),
+            ...(existing?.tmuxWindowName
+                ? { tmuxWindowName: existing.tmuxWindowName }
+                : {}),
+            ...(typeof existing?.tmuxWindowIndex === "number"
+                ? { tmuxWindowIndex: existing.tmuxWindowIndex }
+                : {}),
+            ...(existing?.tmuxPaneId ? { tmuxPaneId: existing.tmuxPaneId } : {}),
+            ...(typeof existing?.tmuxPaneIndex === "number"
+                ? { tmuxPaneIndex: existing.tmuxPaneIndex }
+                : {}),
+            ...(existing?.tmuxTarget ? { tmuxTarget: existing.tmuxTarget } : {}),
+            ...(existing?.lastTmuxNudgeAt
+                ? { lastTmuxNudgeAt: existing.lastTmuxNudgeAt }
+                : {}),
+            ...(existing?.lastSeenToolsHash
+                ? { lastSeenToolsHash: existing.lastSeenToolsHash }
+                : {}),
+            ...(existing?.lastNotifiedToolsHash
+                ? { lastNotifiedToolsHash: existing.lastNotifiedToolsHash }
+                : {}),
+            updatedAt,
+        });
+        this.projectIdentityResolver.persistSessionMarker({
+            cwd: resolved.cwd,
+            sessionId: resolved.sessionId,
+            sessionLabel: label,
+        });
+        this.logger.info("Session renamed", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            sessionLabel: label,
+        });
+        return {
+            renamed: true,
+            session_id: resolved.sessionId,
+            session_label: label,
+            updated_at: updatedAt,
+        };
+    }
+    async getContext(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const binding = await this.bindingStore.getBinding(resolved.sessionId);
+        const linkedSession = session?.linkedSessionId
+            ? await this.sessionStore.getSession(session.linkedSessionId)
+            : null;
+        this.logger.debug("Session context requested", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            exists: Boolean(session),
+            hasBinding: Boolean(binding),
+        });
+        const statusMessage = binding
+            ? session?.tmuxTarget
+                ? "Telegram pairing is active for this session. A tmux target is configured, so ordinary Telegram messages can wake the agent through tmux nudges."
+                : "Telegram pairing is active for this session. No tmux target is configured, so inbox handling requires passive MCP checks."
+            : session
+                ? "Session metadata exists, but Telegram pairing is not active."
+                : "Session metadata and Telegram pairing are both absent.";
+        return {
+            session_id: resolved.sessionId,
+            exists: Boolean(session),
+            has_binding: Boolean(binding),
+            status_message: statusMessage,
+            ...(session
+                ? {
+                    context: {
+                        ...(session.label ? { session_label: session.label } : {}),
+                        ...(session.cwd ? { cwd: session.cwd } : {}),
+                        ...(session.linkedSessionId
+                            ? { linked_session_id: session.linkedSessionId }
+                            : {}),
+                        ...(linkedSession?.label
+                            ? { linked_session_label: linkedSession.label }
+                            : {}),
+                        ...(session.activeProjectUuid
+                            ? { active_project_uuid: session.activeProjectUuid }
+                            : {}),
+                        ...(session.activeProjectName
+                            ? { active_project_name: session.activeProjectName }
+                            : {}),
+                        ...(session.task ? { task: session.task } : {}),
+                        ...(session.summary ? { summary: session.summary } : {}),
+                        ...(session.files ? { files: session.files } : {}),
+                        ...(session.decisions ? { decisions: session.decisions } : {}),
+                        ...(session.risks ? { risks: session.risks } : {}),
+                        updated_at: session.updatedAt,
+                    },
+                }
+                : {}),
+            ...(binding
+                ? {
+                    binding: {
+                        telegram_chat_id: binding.telegramChatId,
+                        telegram_user_id: binding.telegramUserId,
+                        ...(binding.telegramUsername
+                            ? { telegram_username: binding.telegramUsername }
+                            : {}),
+                        linked_at: binding.linkedAt,
+                    },
+                }
+                : {}),
+            ...(session
+                ? {
+                    tmux: {
+                        configured: Boolean(session.tmuxTarget),
+                        ...(session.tmuxSessionName
+                            ? { tmux_session_name: session.tmuxSessionName }
+                            : {}),
+                        ...(session.tmuxWindowName
+                            ? { tmux_window_name: session.tmuxWindowName }
+                            : {}),
+                        ...(typeof session.tmuxWindowIndex === "number"
+                            ? { tmux_window_index: session.tmuxWindowIndex }
+                            : {}),
+                        ...(session.tmuxPaneId
+                            ? { tmux_pane_id: session.tmuxPaneId }
+                            : {}),
+                        ...(typeof session.tmuxPaneIndex === "number"
+                            ? { tmux_pane_index: session.tmuxPaneIndex }
+                            : {}),
+                        ...(session.tmuxTarget
+                            ? { tmux_target: session.tmuxTarget }
+                            : {}),
+                        ...(session.lastTmuxNudgeAt
+                            ? { last_nudge_at: session.lastTmuxNudgeAt }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+    }
+    async clearContext(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const existing = await this.sessionStore.getSession(resolved.sessionId);
+        await this.sessionStore.clearSession(resolved.sessionId);
+        await this.bindingStore.clearBinding(resolved.sessionId);
+        this.projectIdentityResolver.removeSessionMarker(existing?.cwd || resolved.cwd);
+        this.logger.info("Session context cleared", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            clearedPairing: true,
+        });
+        return {
+            cleared: true,
+            session_id: resolved.sessionId,
+            cleared_pairing: true,
+        };
+    }
+    async setTmuxTarget(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const existing = await this.sessionStore.getSession(resolved.sessionId);
+        const updatedAt = new Date().toISOString();
+        const sanitizedTarget = (0, redactSecrets_1.redactSecrets)(input.tmux_target);
+        const sanitizedSessionName = input.tmux_session_name
+            ? (0, redactSecrets_1.redactSecrets)(input.tmux_session_name)
+            : existing?.tmuxSessionName;
+        const sanitizedWindowName = input.tmux_window_name
+            ? (0, redactSecrets_1.redactSecrets)(input.tmux_window_name)
+            : existing?.tmuxWindowName;
+        const sanitizedPaneId = input.tmux_pane_id
+            ? (0, redactSecrets_1.redactSecrets)(input.tmux_pane_id)
+            : existing?.tmuxPaneId;
+        await this.sessionStore.setSession({
+            sessionId: resolved.sessionId,
+            ...(existing?.label
+                ? { label: existing.label }
+                : resolved.sessionLabel
+                    ? { label: (0, redactSecrets_1.redactSecrets)(resolved.sessionLabel) }
+                    : {}),
+            ...(existing?.cwd ? { cwd: existing.cwd } : { cwd: resolved.cwd }),
+            ...(existing?.linkedSessionId
+                ? { linkedSessionId: existing.linkedSessionId }
+                : {}),
+            ...(existing?.activeProjectUuid
+                ? { activeProjectUuid: existing.activeProjectUuid }
+                : {}),
+            ...(existing?.activeProjectName
+                ? { activeProjectName: existing.activeProjectName }
+                : {}),
+            ...(existing?.task ? { task: existing.task } : {}),
+            ...(existing?.summary ? { summary: existing.summary } : {}),
+            ...(existing?.files ? { files: existing.files } : {}),
+            ...(existing?.decisions ? { decisions: existing.decisions } : {}),
+            ...(existing?.risks ? { risks: existing.risks } : {}),
+            ...(sanitizedSessionName
+                ? { tmuxSessionName: sanitizedSessionName }
+                : {}),
+            ...(sanitizedWindowName ? { tmuxWindowName: sanitizedWindowName } : {}),
+            ...(typeof input.tmux_window_index === "number"
+                ? { tmuxWindowIndex: input.tmux_window_index }
+                : typeof existing?.tmuxWindowIndex === "number"
+                    ? { tmuxWindowIndex: existing.tmuxWindowIndex }
+                    : {}),
+            ...(sanitizedPaneId ? { tmuxPaneId: sanitizedPaneId } : {}),
+            ...(typeof input.tmux_pane_index === "number"
+                ? { tmuxPaneIndex: input.tmux_pane_index }
+                : typeof existing?.tmuxPaneIndex === "number"
+                    ? { tmuxPaneIndex: existing.tmuxPaneIndex }
+                    : {}),
+            tmuxTarget: sanitizedTarget,
+            ...(existing?.lastTmuxNudgeAt
+                ? { lastTmuxNudgeAt: existing.lastTmuxNudgeAt }
+                : {}),
+            updatedAt,
+        });
+        this.projectIdentityResolver.persistSessionMarker({
+            cwd: resolved.cwd,
+            sessionId: resolved.sessionId,
+            sessionLabel: existing?.label || resolved.sessionLabel,
+        });
+        this.logger.info("Session tmux target saved", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            tmuxSessionName: sanitizedSessionName,
+            tmuxWindowName: sanitizedWindowName,
+            tmuxWindowIndex: input.tmux_window_index,
+            tmuxPaneId: sanitizedPaneId,
+            tmuxPaneIndex: input.tmux_pane_index,
+            tmuxTarget: sanitizedTarget,
+        });
+        return {
+            session_id: resolved.sessionId,
+            tmux_target: sanitizedTarget,
+            ...(sanitizedSessionName
+                ? { tmux_session_name: sanitizedSessionName }
+                : {}),
+            ...(sanitizedWindowName
+                ? { tmux_window_name: sanitizedWindowName }
+                : {}),
+            ...(typeof input.tmux_window_index === "number"
+                ? { tmux_window_index: input.tmux_window_index }
+                : {}),
+            ...(sanitizedPaneId ? { tmux_pane_id: sanitizedPaneId } : {}),
+            ...(typeof input.tmux_pane_index === "number"
+                ? { tmux_pane_index: input.tmux_pane_index }
+                : {}),
+            status_message: "tmux target saved for this session. For a paired session, the service can now nudge this tmux pane when a new non-reply Telegram message is stored in inbox.",
+        };
+    }
+    async getTmuxTarget(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const configured = Boolean(session?.tmuxTarget);
+        this.logger.debug("Session tmux target requested", {
+            sessionId: resolved.sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            configured,
+        });
+        return {
+            session_id: resolved.sessionId,
+            configured,
+            ...(session?.tmuxTarget ? { tmux_target: session.tmuxTarget } : {}),
+            ...(session?.tmuxSessionName
+                ? { tmux_session_name: session.tmuxSessionName }
+                : {}),
+            ...(session?.tmuxWindowName
+                ? { tmux_window_name: session.tmuxWindowName }
+                : {}),
+            ...(typeof session?.tmuxWindowIndex === "number"
+                ? { tmux_window_index: session.tmuxWindowIndex }
+                : {}),
+            ...(session?.tmuxPaneId ? { tmux_pane_id: session.tmuxPaneId } : {}),
+            ...(typeof session?.tmuxPaneIndex === "number"
+                ? { tmux_pane_index: session.tmuxPaneIndex }
+                : {}),
+            ...(session?.lastTmuxNudgeAt
+                ? { last_nudge_at: session.lastTmuxNudgeAt }
+                : {}),
+            status_message: configured
+                ? "tmux target is configured for this session."
+                : "tmux target is not configured for this session.",
+        };
+    }
+}
+exports.SessionContextService = SessionContextService;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetSessionContextTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class SetSessionContextTool {
+    sessionContextService;
+    constructor(sessionContextService) {
+        this.sessionContextService = sessionContextService;
+    }
+    register(server) {
+        server.registerTool("set_session_context", {
+            title: "Set Session Context",
+            description: "Save compact reusable context for the session: current task, summary, decisions, files, and risks. Use this to leave a short durable working state for later Telegram-driven continuation.",
+            inputSchema: schema_1.setSessionContextInputSchema,
+            outputSchema: schema_1.setSessionContextOutputSchema,
+        }, async (args) => {
+            const output = await this.sessionContextService.setContext(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.SetSessionContextTool = SetSessionContextTool;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetTmuxTargetTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class SetTmuxTargetTool {
+    sessionContextService;
+    constructor(sessionContextService) {
+        this.sessionContextService = sessionContextService;
+    }
+    register(server) {
+        server.registerTool("set_tmux_target", {
+            title: "Set tmux Target",
+            description: "Use this to repair or complete Telegram session setup after pairing, or when tmux pane/session changed. Store the tmux pane target for a session so the long-running MCP service can nudge the agent to check Telegram inbox when new ordinary Telegram messages arrive.",
+            inputSchema: schema_1.setTmuxTargetInputSchema,
+            outputSchema: schema_1.setTmuxTargetOutputSchema,
+        }, async (args) => {
+            const output = await this.sessionContextService.setTmuxTarget(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.SetTmuxTargetTool = SetTmuxTargetTool;

package/dist/services/features/telegram-mcp/src/features/tools-sync/model/refreshToolsMarkdownService.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshToolsMarkdownService = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function normalizeGatewayBaseUrl(value) {
+    const url = new URL(value);
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    if (!url.pathname.endsWith("/gateway")) {
+        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+    }
+    return url;
+}
+function computeContentHash(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+class RefreshToolsMarkdownService {
+    config;
+    sessionStore;
+    logger;
+    projectIdentityResolver;
+    constructor(config, sessionStore, logger, projectIdentityResolver) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    async refresh(input = {}) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const workspaceDir = input.cwd?.trim()
+            ? (0, node_path_1.resolve)(input.cwd.trim())
+            : session?.cwd?.trim()
+                ? (0, node_path_1.resolve)(session.cwd.trim())
+                : undefined;
+        const saveLocally = input.save_locally !== false;
+        const gatewayToolsPath = (0, node_path_1.join)(process.cwd(), "TOOLS.md");
+        let source = "local";
+        let content;
+        if (this.config.distributed.gatewayPublicUrl) {
+            const url = normalizeGatewayBaseUrl(this.config.distributed.gatewayPublicUrl);
+            url.pathname = `${url.pathname}/tools-md`.replace(/\/{2,}/gu, "/");
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    ...(this.config.distributed.gatewayAuthToken
+                        ? { authorization: `Bearer ${this.config.distributed.gatewayAuthToken}` }
+                        : {}),
+                },
+            });
+            if (!response.ok) {
+                const message = await response.text();
+                throw new Error(`Gateway TOOLS.md request failed with status ${response.status}: ${message || response.statusText}`);
+            }
+            content = await response.text();
+            source = "gateway";
+        }
+        else {
+            content = (0, node_fs_1.readFileSync)(gatewayToolsPath, "utf8");
+        }
+        if (!workspaceDir) {
+            throw new Error("Could not resolve target workspace for TOOLS.md. Pair the session with cwd first or pass cwd/session_id explicitly.");
+        }
+        const toolsPath = (0, node_path_1.join)(workspaceDir, "TOOLS.md");
+        if (saveLocally) {
+            (0, node_fs_1.writeFileSync)(toolsPath, content, "utf8");
+            const appliedHash = computeContentHash(content);
+            await this.sessionStore.setSession({
+                sessionId: resolved.sessionId,
+                ...(session?.label ? { label: session.label } : {}),
+                ...(session?.cwd ? { cwd: session.cwd } : { cwd: workspaceDir }),
+                ...(session?.linkedSessionId
+                    ? { linkedSessionId: session.linkedSessionId }
+                    : {}),
+                ...(session?.activeProjectUuid
+                    ? { activeProjectUuid: session.activeProjectUuid }
+                    : {}),
+                ...(session?.activeProjectName
+                    ? { activeProjectName: session.activeProjectName }
+                    : {}),
+                ...(session?.task ? { task: session.task } : {}),
+                ...(session?.summary ? { summary: session.summary } : {}),
+                ...(session?.files ? { files: session.files } : {}),
+                ...(session?.decisions ? { decisions: session.decisions } : {}),
+                ...(session?.risks ? { risks: session.risks } : {}),
+                ...(session?.tmuxSessionName
+                    ? { tmuxSessionName: session.tmuxSessionName }
+                    : {}),
+                ...(session?.tmuxWindowName
+                    ? { tmuxWindowName: session.tmuxWindowName }
+                    : {}),
+                ...(typeof session?.tmuxWindowIndex === "number"
+                    ? { tmuxWindowIndex: session.tmuxWindowIndex }
+                    : {}),
+                ...(session?.tmuxPaneId ? { tmuxPaneId: session.tmuxPaneId } : {}),
+                ...(typeof session?.tmuxPaneIndex === "number"
+                    ? { tmuxPaneIndex: session.tmuxPaneIndex }
+                    : {}),
+                ...(session?.tmuxTarget ? { tmuxTarget: session.tmuxTarget } : {}),
+                ...(session?.lastTmuxNudgeAt
+                    ? { lastTmuxNudgeAt: session.lastTmuxNudgeAt }
+                    : {}),
+                lastSeenToolsHash: appliedHash,
+                lastNotifiedToolsHash: appliedHash,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        this.logger.info("TOOLS.md refreshed", {
+            source,
+            saved: saveLocally,
+            path: toolsPath,
+            bytes: Buffer.byteLength(content, "utf8"),
+        });
+        return {
+            source,
+            saved: saveLocally,
+            bytes: Buffer.byteLength(content, "utf8"),
+            ...(saveLocally ? { path: toolsPath } : {}),
+        };
+    }
+}
+exports.RefreshToolsMarkdownService = RefreshToolsMarkdownService;