@deadragdoll/tellymcp 0.0.7 → 0.0.8

package/README-ru.md

@@ -73,6 +73,12 @@ Telegram HITL здесь тоже есть, но он не исчерпывае
 - partner notes и partner files
 - tools sync и version checks
 
+Важно для `Share`:
+
+- текущая сессия должна выполнить работу сама
+- target-сессии отправляется только результат
+- исходное поручение не должно пересылаться дальше как новая задача
+
 Полный список MCP tools лучше держать ниже по README и в самом MCP server, а не на первом экране.
 
 ## Prerequisites
@@ -121,6 +127,10 @@ tmux attach -t backend
 
 Если агентов несколько, лучше запускать каждого в своей tmux-сессии или pane и привязывать отдельно.
 
+Если tmux pane пересоздан и его `pane_id` изменился, TellyMCP теперь пытается автоматически восстановить актуальный target по сохранённым tmux session/window/pane hints.
+
+Если авто-восстановление не удалось, в Telegram придёт operational warning, а не только запись в backend log.
+
 ## Быстрый старт
 
 ### 1. Standalone client без шлюза

package/README.md

@@ -122,6 +122,10 @@ Use short, meaningful names such as:
 
 If you run multiple agents, put each one in its own tmux session or pane and pair them separately.
 
+If a tmux pane is recreated and its pane id changes, TellyMCP now tries to recover the live pane target automatically from saved tmux session, window, and pane hints.
+
+If auto-recovery fails, Telegram sends an operational warning so the problem is visible to the human user, not only in backend logs.
+
 ## Quick start
 
 ### Standalone client node
@@ -490,6 +494,8 @@ Current file model:
 - `vfs/minio` are no longer part of the active Telegram file exchange path
 - if an agent must send a real local file to a partner, prefer `send_partner_file`
   over plain `send_partner_note`
+- for `Share`, the current session must do the work itself and send only the result
+- `Share` must not forward the original task into the target session as a new assignment
 
 Current presence model:
 

package/VERSION.md

@@ -4,6 +4,35 @@ Public, user-facing release notes for published versions of `@deadragdoll/tellym
 
 For detailed engineering history, refactors, and internal development notes, see [CHANGELOG.md](CHANGELOG.md).
 
+## 0.0.8
+
+### Added
+- Unified logging model based on `pino`:
+  - pretty console output by default
+  - optional JSONL file sink for Alloy or other collectors
+  - `LOG_FILE_ENABLED=true`
+  - `LOG_FILE_PATH=.tellymcp/log.jsonl`
+- Better tmux recovery behavior:
+  - when a saved pane target becomes stale after tmux recreation, TellyMCP now tries to recover the live pane automatically from stored tmux session/window/pane hints
+  - if auto-recovery fails, Telegram sends a clear operational warning instead of leaving the problem only in logs
+- Stronger `Share` execution guidance:
+  - the current session must do the work itself
+  - it must send only the result
+  - it must not forward the original task to the target session as a new assignment
+
+### Changed
+- Runtime identity and service labels now use `tellymcp` naming consistently instead of older `telegram-human-mcp` tags.
+- MCP server metadata now reports the current package version and `tellymcp` service name.
+- Logging config is now simpler:
+  - one console logging model
+  - one optional JSON file sink
+  - optional `LogFeed` buffer for UI diagnostics
+
+### Fixed
+- Stale tmux pane ids like `%1 -> %2` no longer require manual user understanding before the service can try to wake the session again.
+- Broken tmux nudge targets are now visible to the user in Telegram, not only in backend logs.
+- `Share` inbox instructions are now explicit enough to reduce the chance that one agent re-delegates the task back into the collaboration graph.
+
 ## 0.0.3
 
 ### Added

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

@@ -19,6 +19,7 @@ const proxyFetch_1 = require("./proxyFetch");
 const client_1 = require("../tmux/client");
 const versionHandshake_1 = require("../../lib/version/versionHandshake");
 const LOCAL_INDEX_FILE_NAME = "LOCAL_INDEX.md";
+const TMUX_NUDGE_FAILURE_NOTICE_COOLDOWN_MS = 5 * 60 * 1000;
 function trimTrailingSlashes(value) {
     return value.replace(/\/+$/u, "");
 }
@@ -306,6 +307,7 @@ class TelegramTransport {
     screenshotMessageMenu;
     waiters = new Map();
     tmuxNudgeDebounceTimers = new Map();
+    tmuxNudgeFailureNoticeAt = new Map();
     pendingRenames = new Map();
     pendingBroadcasts = new Map();
     pendingPartnerNotes = new Map();
@@ -2585,22 +2587,117 @@ class TelegramTransport {
             return;
         }
         await this.sendTypingForSession(sessionId);
-        await (0, client_1.sendTmuxLiteralLine)(this.config.tmux, session.tmuxTarget, input.message);
+        let tmuxTarget = session.tmuxTarget;
+        try {
+            await (0, client_1.sendTmuxLiteralLine)(this.config.tmux, tmuxTarget, input.message);
+        }
+        catch (error) {
+            if ((0, client_1.isTmuxTargetInvalidError)(error)) {
+                const recoveredTarget = await this.tryRecoverTmuxTarget(sessionId, session);
+                if (recoveredTarget) {
+                    tmuxTarget = recoveredTarget;
+                    await (0, client_1.sendTmuxLiteralLine)(this.config.tmux, recoveredTarget, input.message);
+                }
+                else {
+                    await this.notifyTmuxTargetInvalid(sessionId, session, error);
+                    throw error;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
         const lastTmuxNudgeAt = new Date(nowMs).toISOString();
         await this.sessionStore.setSession({
             ...session,
+            tmuxTarget,
+            ...(tmuxTarget ? { tmuxPaneId: tmuxTarget } : {}),
             lastTmuxNudgeAt,
         });
+        this.tmuxNudgeFailureNoticeAt.delete(sessionId);
         this.logger.info("tmux nudge sent", {
             sessionId,
             reason: input.reason,
             message: input.message,
             tmuxSessionName: session.tmuxSessionName,
-            tmuxTarget: session.tmuxTarget,
+            tmuxTarget,
             inboxCount,
             lastTmuxNudgeAt,
         });
     }
+    async tryRecoverTmuxTarget(sessionId, session) {
+        const recoveredTarget = await (0, client_1.resolveTmuxTargetFromHint)(this.config.tmux, {
+            tmuxSessionName: session.tmuxSessionName,
+            tmuxWindowName: session.tmuxWindowName,
+            tmuxWindowIndex: session.tmuxWindowIndex,
+            tmuxPaneId: session.tmuxPaneId,
+            tmuxPaneIndex: session.tmuxPaneIndex,
+            tmuxTarget: session.tmuxTarget,
+        });
+        if (!recoveredTarget || recoveredTarget === session.tmuxTarget) {
+            return recoveredTarget;
+        }
+        await this.sessionStore.setSession({
+            ...session,
+            tmuxTarget: recoveredTarget,
+            tmuxPaneId: recoveredTarget,
+            updatedAt: new Date().toISOString(),
+        });
+        this.logger.warn("tmux target auto-recovered", {
+            sessionId,
+            previousTmuxTarget: session.tmuxTarget,
+            recoveredTmuxTarget: recoveredTarget,
+            tmuxSessionName: session.tmuxSessionName,
+            tmuxWindowName: session.tmuxWindowName,
+            tmuxWindowIndex: session.tmuxWindowIndex,
+            tmuxPaneIndex: session.tmuxPaneIndex,
+        });
+        return recoveredTarget;
+    }
+    async notifyTmuxTargetInvalid(sessionId, session, error) {
+        const binding = await this.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            return;
+        }
+        const nowMs = Date.now();
+        const lastNoticeAt = this.tmuxNudgeFailureNoticeAt.get(sessionId);
+        if (lastNoticeAt &&
+            nowMs - lastNoticeAt < TMUX_NUDGE_FAILURE_NOTICE_COOLDOWN_MS) {
+            return;
+        }
+        this.tmuxNudgeFailureNoticeAt.set(sessionId, nowMs);
+        const sessionLabel = session.label ?? sessionId;
+        const tmuxTarget = session.tmuxTarget ?? "unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        try {
+            await this.sendNotification({
+                sessionId,
+                sessionLabel: "TellyMCP",
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: [
+                    `⚠️ Автоматический tmux nudge для сессии ${sessionLabel} не сработал.`,
+                    `Сохранённый tmux target больше недействителен: ${tmuxTarget}`,
+                    `Ошибка: ${errorMessage}`,
+                    "Обычно это значит, что pane/window/session был пересоздан.",
+                    "Перепривяжи tmux target для этой сессии.",
+                ].join("\n"),
+            });
+        }
+        catch (notifyError) {
+            this.logger.warn("Failed to deliver tmux target failure notification", {
+                sessionId,
+                tmuxTarget,
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+                notifyError: notifyError instanceof Error
+                    ? (notifyError.stack ?? notifyError.message)
+                    : String(notifyError),
+            });
+        }
+    }
     async sendTypingForSession(sessionId) {
         const binding = await this.bindingStore.getBinding(sessionId);
         if (!binding) {
@@ -6454,7 +6551,7 @@ class TelegramTransport {
             telegramUserId: input.principal.telegramUserId,
             sourceTelegramMessageId: input.sourceTelegramMessageId,
             text: [
-                "Пользователь просит текущую сессию подготовить сообщение для другой сессии.",
+                "Пользователь просит текущую сессию выполнить работу и отправить результат другой сессии.",
                 `Маршрут отправки: ${sourceLabel} -> ${targetLabel}`,
                 `Тип: ${input.kind}`,
                 `Кратко: ${input.summary}`,
@@ -6466,6 +6563,9 @@ class TelegramTransport {
                 "Содержимое для отправки:",
                 input.message,
                 "",
+                "Не пересылай это как новую задачу в target-сессию.",
+                "Сначала выполни работу в текущей сессии сам.",
+                "Через send_partner_note или send_partner_file отправляй только результат, а не исходное поручение.",
                 "Не используй linked partner для отправки. Передай target_session_id явно в send_partner_note.",
                 "После подготовки обязательно используй send_partner_note.",
                 "Задача не завершена, пока send_partner_note не отработал успешно.",

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

@@ -10,6 +10,8 @@ exports.listXchangeFiles = listXchangeFiles;
 exports.deleteXchangeFile = deleteXchangeFile;
 exports.readWorkspaceFile = readWorkspaceFile;
 exports.isTmuxUnavailableError = isTmuxUnavailableError;
+exports.isTmuxTargetInvalidError = isTmuxTargetInvalidError;
+exports.resolveTmuxTargetFromHint = resolveTmuxTargetFromHint;
 exports.getTmuxWindowHeight = getTmuxWindowHeight;
 exports.captureTmuxPaneRange = captureTmuxPaneRange;
 exports.captureVisibleTmuxPane = captureVisibleTmuxPane;
@@ -189,6 +191,79 @@ function isTmuxUnavailableError(error) {
         message.includes("ENOENT") ||
         message.includes("tmux is unavailable"));
 }
+function isTmuxTargetInvalidError(error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    return (message.includes("can't find pane") ||
+        message.includes("can't find window") ||
+        message.includes("can't find session"));
+}
+async function listTmuxPanes(config) {
+    const { stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
+        "list-panes",
+        "-a",
+        "-F",
+        "#{session_name}\t#{window_name}\t#{window_index}\t#{pane_id}\t#{pane_index}",
+    ]));
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map((line) => {
+        const [sessionName = "", windowName = "", windowIndexRaw = "", paneId = "", paneIndexRaw = ""] = line.split("\t");
+        return {
+            sessionName,
+            windowName,
+            windowIndex: Number.parseInt(windowIndexRaw, 10),
+            paneId,
+            paneIndex: Number.parseInt(paneIndexRaw, 10),
+        };
+    })
+        .filter((pane) => pane.sessionName &&
+        pane.paneId &&
+        Number.isFinite(pane.windowIndex) &&
+        Number.isFinite(pane.paneIndex));
+}
+async function resolveTmuxTargetFromHint(config, hint) {
+    const panes = await listTmuxPanes(config);
+    const byPaneId = hint.tmuxPaneId
+        ? panes.find((pane) => pane.paneId === hint.tmuxPaneId)
+        : null;
+    if (byPaneId) {
+        return byPaneId.paneId;
+    }
+    const exactMatch = panes.find((pane) => {
+        if (!hint.tmuxSessionName) {
+            return false;
+        }
+        if (pane.sessionName !== hint.tmuxSessionName) {
+            return false;
+        }
+        if (typeof hint.tmuxWindowIndex === "number" &&
+            pane.windowIndex !== hint.tmuxWindowIndex) {
+            return false;
+        }
+        if (typeof hint.tmuxPaneIndex === "number" &&
+            pane.paneIndex !== hint.tmuxPaneIndex) {
+            return false;
+        }
+        if (hint.tmuxWindowName &&
+            pane.windowName !== hint.tmuxWindowName) {
+            return false;
+        }
+        return true;
+    });
+    if (exactMatch) {
+        return exactMatch.paneId;
+    }
+    const fallbackBySessionAndPane = panes.find((pane) => {
+        if (!hint.tmuxSessionName || typeof hint.tmuxPaneIndex !== "number") {
+            return false;
+        }
+        return (pane.sessionName === hint.tmuxSessionName &&
+            pane.paneIndex === hint.tmuxPaneIndex);
+    });
+    return fallbackBySessionAndPane?.paneId ?? null;
+}
 async function getTmuxWindowHeight(config, target) {
     const { stdout: heightRaw } = await execFileOutputAsync("tmux", buildTmuxArgs(config, ["display-message", "-p", "-t", target, "#{window_height}"]));
     const height = Number.parseInt(heightRaw.trim(), 10);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deadragdoll/tellymcp",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "TellyMCP - Telegram control plane for MCP-connected coding agents",
   "main": "dist/services/features/telegram-mcp/runtime.service.js",
   "bin": {