@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/services/features/telegram-mcp/src/shared/lib/terminalPromptDetection.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTerminalInteractivePrompt = detectTerminalInteractivePrompt;
+const node_crypto_1 = require("node:crypto");
+const ANSI_ESCAPE_SEQUENCE_PATTERN = 
+// eslint-disable-next-line no-control-regex
+/\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/gu;
+const STRONG_PATTERNS = [
+    {
+        pattern: /\[(?:[Yy]\/[Nn]|[Nn]\/[Yy])\]|\((?:[Yy]\/[Nn]|[Nn]\/[Yy])\)/u,
+        score: 5,
+        reason: "yes_no_prompt",
+    },
+    {
+        pattern: /press\s+enter\s+to\s+continue|hit\s+enter\s+to\s+continue/iu,
+        score: 5,
+        reason: "press_enter_prompt",
+    },
+    {
+        pattern: /press\s+enter\s+to\s+confirm\b.*\besc\s+to\s+cancel/iu,
+        score: 5,
+        reason: "confirm_cancel_prompt",
+    },
+    {
+        pattern: /waiting\s+for\s+(?:user\s+)?input|awaiting\s+(?:user\s+)?(?:input|confirmation)|requires?\s+approval|need\s+your\s+(?:input|permission|approval)|cannot\s+continue\s+without/iu,
+        score: 4,
+        reason: "waiting_for_input",
+    },
+    {
+        pattern: /\b(do\s+you\s+want|are\s+you\s+sure|would\s+you\s+like|should\s+i|can\s+i\s+go\s+ahead|may\s+i\s+proceed)\b/iu,
+        score: 4,
+        reason: "direct_question_phrase",
+    },
+    {
+        pattern: /\[\s*!\s*\]\s*action\s+required\b/iu,
+        score: 5,
+        reason: "action_required_banner",
+    },
+    {
+        pattern: /\bfield\s+\d+\/\d+\s+\(\d+\s+required\s+unanswered\)/iu,
+        score: 5,
+        reason: "required_unanswered_field",
+    },
+    {
+        pattern: /\ballow\s+the\s+.+\?\s*$/iu,
+        score: 4,
+        reason: "allow_question",
+    },
+    {
+        pattern: /\brun\s+the\s+tool\s+and\s+continue\b/iu,
+        score: 4,
+        reason: "tool_continue_prompt",
+    },
+    {
+        pattern: /\bwould\s+you\s+like\s+to\s+run\s+the\s+following\s+command\b/iu,
+        score: 5,
+        reason: "command_approval_prompt",
+    },
+];
+const MEDIUM_PATTERNS = [
+    {
+        pattern: /\b(confirm|approve|allow|continue|proceed|select|choose)\b/iu,
+        score: 1,
+        reason: "action_keyword",
+    },
+    {
+        pattern: /\?\s*$/u,
+        score: 1,
+        reason: "question_mark",
+    },
+    {
+        pattern: /\b(?:always\s+allow|allow\s+for\s+this\s+session|cancel\s+this\s+tool\s+call)\b/iu,
+        score: 1,
+        reason: "tool_choice_keyword",
+    },
+];
+const NUMBERED_CHOICE_LINE_PATTERN = /^(?:[>›*•-]\s*)?\d+\.\s+.+$/u;
+const CONFIRM_CANCEL_FOOTER_PATTERN = /\b(?:press\s+enter\s+to\s+confirm|enter\s+to\s+submit)\b.*\besc\s+to\s+cancel\b/iu;
+const SUBMIT_CANCEL_FOOTER_PATTERN = /\benter\s+to\s+submit\b.*\besc\s+to\s+cancel\b/iu;
+const CONTINUE_FOOTER_PATTERN = /\b(?:press\s+enter\s+to\s+continue|hit\s+enter\s+to\s+continue)\b/iu;
+const NUMBERED_HOTKEY_FOOTER_PATTERN = /\bpress\s+(?:(?:\d+\s*,\s*)+\s*(?:or\s+)?\d+\s*,?\s*)?(?:enter\b.*\besc|esc\b.*\benter|\d+\b.*\benter|\d+\b.*\besc).*\b(?:quit|continue|cancel|confirm|submit)\b/iu;
+const POSITIVE_CHOICE_PATTERN = /\b(?:yes|allow|approve|proceed|continue)\b/iu;
+const NEGATIVE_CHOICE_PATTERN = /\b(?:no|cancel|deny|reject)\b/iu;
+const STICKY_CHOICE_PATTERN = /\bdon'?t\s+ask\s+again|always\s+allow|for\s+this\s+session\b/iu;
+const SKIP_CHOICE_PATTERN = /\bskip\b/iu;
+const LEADING_SELECTION_MARKER_PATTERN = /^(?:[>›*•-]\s*)(?=\d+\.\s)/u;
+const ACTION_HINT_PATTERN = /\b(?:press|input|choose|choice|select|option|enter|esc(?:ape)?|accept|decline|confirm|cancel|continue|proceed|yes|no)\b|(?:\[[Yy](?:es)?\/[Nn](?:o)?\])|(?:\([Yy](?:es)?\/[Nn](?:o)?\))/u;
+function normalizeLine(line) {
+    return line
+        .replaceAll("\r", "")
+        .replace(ANSI_ESCAPE_SEQUENCE_PATTERN, "")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+function isNoiseLine(line) {
+    if (!line) {
+        return true;
+    }
+    if (line.length > 260) {
+        return true;
+    }
+    return (/^\[[0-9]{4}-[0-9]{2}-[0-9]{2}\b/u.test(line) ||
+        /^at\s+.+\(.+\)$/u.test(line) ||
+        /^diff --git\b/u.test(line) ||
+        /^(---|\+\+\+|@@)\b/u.test(line) ||
+        /^[~/.\w-]+:\d+:\d+/u.test(line) ||
+        /^https?:\/\/\S+$/u.test(line));
+}
+function scoreStrongLine(line) {
+    const contributions = [];
+    for (const candidate of STRONG_PATTERNS) {
+        if (candidate.pattern.test(line)) {
+            contributions.push({
+                score: candidate.score,
+                reason: candidate.reason,
+            });
+        }
+    }
+    return contributions;
+}
+function scoreMediumLine(line, strategy) {
+    const contributions = [];
+    for (const candidate of MEDIUM_PATTERNS) {
+        if (candidate.pattern.test(line)) {
+            contributions.push({
+                score: candidate.score,
+                reason: candidate.reason,
+            });
+        }
+    }
+    if (strategy === "balanced" &&
+        /\b(input|reply|answer|decision|permission|approval)\b/iu.test(line)) {
+        contributions.push({
+            score: 1,
+            reason: "balanced_context_keyword",
+        });
+    }
+    return contributions;
+}
+function isStrongReason(reason) {
+    return STRONG_PATTERNS.some((candidate) => candidate.reason === reason);
+}
+function collectCandidateLines(rawText, maxLines) {
+    const normalized = rawText
+        .split("\n")
+        .map(normalizeLine)
+        .filter((line) => line.length > 0);
+    return normalized.slice(-Math.max(1, maxLines));
+}
+function normalizeFingerprintLine(line) {
+    return normalizeLine(line)
+        .replace(LEADING_SELECTION_MARKER_PATTERN, "")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+function buildDetectionFingerprint(strategy, matchedLines) {
+    const normalizedExcerpt = matchedLines
+        .map(normalizeFingerprintLine)
+        .join("\n");
+    return (0, node_crypto_1.createHash)("sha1")
+        .update(`${strategy}\n${normalizedExcerpt}`)
+        .digest("hex");
+}
+function buildExcerptWithContext(candidateLines, matchedLines) {
+    if (matchedLines.length === 0) {
+        return "";
+    }
+    const firstMatchedIndex = candidateLines.findIndex((line) => line === matchedLines[0]);
+    const lastMatchedIndex = matchedLines.length === 1
+        ? firstMatchedIndex
+        : candidateLines.findIndex((line, index) => index >= Math.max(0, firstMatchedIndex) &&
+            line === matchedLines[matchedLines.length - 1]);
+    if (firstMatchedIndex < 0 || lastMatchedIndex < 0) {
+        return matchedLines.slice(-8).join("\n");
+    }
+    const excerptStart = Math.max(0, firstMatchedIndex - 2);
+    const excerptEnd = Math.min(candidateLines.length, lastMatchedIndex + 1);
+    return candidateLines.slice(excerptStart, excerptEnd).slice(-8).join("\n");
+}
+function findChoiceActionBlock(candidateLines) {
+    for (let startIndex = candidateLines.length - 1; startIndex >= 0; startIndex -= 1) {
+        const line = candidateLines[startIndex] ?? "";
+        if (!NUMBERED_CHOICE_LINE_PATTERN.test(line)) {
+            continue;
+        }
+        const choiceLines = [];
+        let firstChoiceIndex = startIndex;
+        while (firstChoiceIndex >= 0) {
+            const currentLine = candidateLines[firstChoiceIndex] ?? "";
+            if (!NUMBERED_CHOICE_LINE_PATTERN.test(currentLine)) {
+                break;
+            }
+            choiceLines.unshift(currentLine);
+            firstChoiceIndex -= 1;
+        }
+        firstChoiceIndex += 1;
+        if (choiceLines.length < 2) {
+            continue;
+        }
+        const lastChoiceIndex = firstChoiceIndex + choiceLines.length - 1;
+        const headerLines = candidateLines.slice(Math.max(0, firstChoiceIndex - 5), firstChoiceIndex);
+        const tailLines = candidateLines.slice(lastChoiceIndex + 1, Math.min(candidateLines.length, lastChoiceIndex + 4));
+        const footerLine = tailLines[0] ?? null;
+        const nearbyLines = [...headerLines, ...tailLines];
+        const hasActionHint = nearbyLines.some((candidate) => ACTION_HINT_PATTERN.test(candidate));
+        const hasChoiceSemantics = POSITIVE_CHOICE_PATTERN.test(choiceLines.join("\n")) ||
+            NEGATIVE_CHOICE_PATTERN.test(choiceLines.join("\n")) ||
+            STICKY_CHOICE_PATTERN.test(choiceLines.join("\n")) ||
+            SKIP_CHOICE_PATTERN.test(choiceLines.join("\n"));
+        if (!hasActionHint && !hasChoiceSemantics) {
+            continue;
+        }
+        return {
+            footerLine,
+            choiceLines,
+            headerLines,
+            tailLines,
+        };
+    }
+    return null;
+}
+function detectChoiceFooterSignals(candidateLines, strategy) {
+    const block = findChoiceActionBlock(candidateLines);
+    if (!block) {
+        return null;
+    }
+    const choiceText = block.choiceLines.join("\n");
+    const contextLines = [
+        ...block.headerLines,
+        ...block.choiceLines,
+        ...(block.footerLine ? [block.footerLine] : []),
+        ...block.tailLines,
+    ];
+    const reasons = new Set(["numbered_choice_group"]);
+    const matchedLines = [
+        ...block.choiceLines,
+        ...(block.footerLine ? [block.footerLine] : []),
+        ...block.tailLines,
+    ];
+    let score = strategy === "balanced" ? 5 : 6;
+    const footerLine = block.footerLine ?? "";
+    if (CONFIRM_CANCEL_FOOTER_PATTERN.test(footerLine)) {
+        reasons.add("confirm_cancel_footer");
+        score += strategy === "balanced" ? 2 : 3;
+    }
+    if (CONTINUE_FOOTER_PATTERN.test(footerLine)) {
+        reasons.add("continue_footer");
+        score += strategy === "balanced" ? 2 : 3;
+    }
+    if (NUMBERED_HOTKEY_FOOTER_PATTERN.test(footerLine)) {
+        reasons.add("numbered_hotkey_footer");
+        score += strategy === "balanced" ? 2 : 3;
+    }
+    if (SUBMIT_CANCEL_FOOTER_PATTERN.test(footerLine)) {
+        reasons.add("submit_cancel_hint");
+    }
+    if (/press\s+enter\s+to\s+confirm\b/iu.test(footerLine)) {
+        reasons.add("confirm_cancel_hint");
+    }
+    if (contextLines.some((line) => ACTION_HINT_PATTERN.test(line))) {
+        reasons.add("action_hint_present");
+        score += 2;
+    }
+    if (POSITIVE_CHOICE_PATTERN.test(choiceText)) {
+        reasons.add("positive_choice_present");
+        score += 2;
+    }
+    if (NEGATIVE_CHOICE_PATTERN.test(choiceText)) {
+        reasons.add("negative_choice_present");
+        score += 2;
+    }
+    if (STICKY_CHOICE_PATTERN.test(choiceText)) {
+        reasons.add("sticky_choice_present");
+        score += 2;
+    }
+    if (SKIP_CHOICE_PATTERN.test(choiceText)) {
+        reasons.add("skip_choice_present");
+        score += 2;
+    }
+    if (reasons.has("positive_choice_present") && reasons.has("negative_choice_present")) {
+        reasons.add("yes_no_choice_group");
+        reasons.add("approval_choice_group");
+        score += 3;
+    }
+    if (reasons.has("positive_choice_present") && reasons.has("skip_choice_present")) {
+        reasons.add("choice_update_group");
+        score += 2;
+    }
+    if (/^(?:[>›*•-]\s*)?(?:\d+\.\s+)?yes,\s+proceed\b/imu.test(choiceText) &&
+        reasons.has("sticky_choice_present")) {
+        reasons.add("proceed_choice_group");
+    }
+    for (const line of contextLines) {
+        for (const contribution of scoreStrongLine(line)) {
+            reasons.add(contribution.reason);
+            score += contribution.score;
+        }
+    }
+    return {
+        score,
+        reasons: Array.from(reasons),
+        matchedLines,
+        promptActions: {
+            numberedOptions: block.choiceLines
+                .map((line) => line.match(/^(?:[>›*•-]\s*)?(\d+)\.\s+/u)?.[1] ?? null)
+                .filter((value) => Boolean(value)),
+            hasEnter: contextLines.some((line) => /\benter\b/iu.test(line)),
+            hasEscape: contextLines.some((line) => /\besc(?:ape)?\b/iu.test(line)),
+        },
+    };
+}
+function detectTerminalInteractivePrompt(rawText, options = {}) {
+    const strategy = options.strategy ?? "strict";
+    const minScore = options.minScore ?? (strategy === "balanced" ? 4 : 5);
+    const candidateLines = collectCandidateLines(rawText, options.maxLines ?? 40);
+    if (candidateLines.length === 0) {
+        return null;
+    }
+    const choiceFooterDetection = detectChoiceFooterSignals(candidateLines, strategy);
+    if (choiceFooterDetection && choiceFooterDetection.score >= minScore) {
+        const matchedLines = choiceFooterDetection.matchedLines.slice(-6);
+        const excerpt = buildExcerptWithContext(candidateLines, matchedLines);
+        const fingerprint = buildDetectionFingerprint(strategy, matchedLines);
+        return {
+            score: choiceFooterDetection.score,
+            fingerprint,
+            excerpt,
+            matchedLines,
+            reasons: choiceFooterDetection.reasons,
+            promptActions: choiceFooterDetection.promptActions,
+        };
+    }
+    const scoredLines = [];
+    let score = 0;
+    const reasons = new Set();
+    for (const line of candidateLines) {
+        if (isNoiseLine(line)) {
+            continue;
+        }
+        const contributions = scoreStrongLine(line);
+        if (contributions.length === 0) {
+            continue;
+        }
+        scoredLines.push({ line, contributions });
+        for (const contribution of contributions) {
+            score += contribution.score;
+            reasons.add(contribution.reason);
+        }
+    }
+    const optionLineCount = candidateLines.filter((line) => /^(\d+\.\s+|[-*]\s+|\[[ xX]\]\s+)/u.test(line)).length;
+    if (scoredLines.length > 0 && optionLineCount >= 2) {
+        score += 3;
+        reasons.add("multiple_options");
+    }
+    const hasStrongReason = Array.from(reasons).some(isStrongReason);
+    const hasGroupedReason = reasons.has("multiple_options");
+    const hasOnlyQuestionMarkReason = reasons.size === 1 && reasons.has("question_mark");
+    if (strategy === "strict") {
+        if (hasOnlyQuestionMarkReason) {
+            return null;
+        }
+        if (!hasStrongReason) {
+            if (!hasGroupedReason) {
+                return null;
+            }
+        }
+    }
+    const canUseMediumSignals = strategy === "balanced" ||
+        hasStrongReason ||
+        hasGroupedReason ||
+        reasons.has("multiple_options");
+    if (canUseMediumSignals) {
+        for (const line of candidateLines) {
+            if (isNoiseLine(line)) {
+                continue;
+            }
+            const contributions = scoreMediumLine(line, strategy);
+            if (contributions.length === 0) {
+                continue;
+            }
+            const existing = scoredLines.find((entry) => entry.line === line);
+            if (existing) {
+                existing.contributions.push(...contributions);
+            }
+            else {
+                scoredLines.push({ line, contributions: [...contributions] });
+            }
+            for (const contribution of contributions) {
+                score += contribution.score;
+                reasons.add(contribution.reason);
+            }
+        }
+    }
+    if (score < minScore || scoredLines.length === 0) {
+        return null;
+    }
+    const matchedLines = scoredLines
+        .map((entry) => entry.line)
+        .slice(-6);
+    const excerpt = buildExcerptWithContext(candidateLines, matchedLines);
+    const fingerprint = buildDetectionFingerprint(strategy, matchedLines);
+    return {
+        score,
+        fingerprint,
+        excerpt,
+        matchedLines,
+        reasons: Array.from(reasons),
+    };
+}

package/dist/services/features/telegram-mcp/src/shared/lib/version/versionHandshake.js

@@ -3,14 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TELLYMCP_CAPABILITIES = exports.TELLYMCP_PROTOCOL_VERSION = void 0;
+exports.TELLYMCP_CAPABILITIES = exports.TELLYMCP_PACKAGE_NAME = exports.TELLYMCP_PROTOCOL_VERSION = void 0;
 exports.parseProtocolVersion = parseProtocolVersion;
 exports.evaluateVersionCompatibility = evaluateVersionCompatibility;
 exports.findPackageRoot = findPackageRoot;
+exports.getTellyMcpPackageRoot = getTellyMcpPackageRoot;
 exports.getTellyMcpPackageVersion = getTellyMcpPackageVersion;
+exports.comparePackageVersions = comparePackageVersions;
+exports.fetchLatestPublishedPackageVersion = fetchLatestPublishedPackageVersion;
+exports.detectAvailablePackageUpdate = detectAvailablePackageUpdate;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 exports.TELLYMCP_PROTOCOL_VERSION = "1.0";
+exports.TELLYMCP_PACKAGE_NAME = "@deadragdoll/tellymcp";
 exports.TELLYMCP_CAPABILITIES = [
     "collab_projects",
     "delivery_status_push",
@@ -103,7 +108,11 @@ function findPackageRoot(startDir) {
         currentDir = parentDir;
     }
 }
+function getTellyMcpPackageRoot(startDir) {
+    return findPackageRoot(startDir);
+}
 let cachedPackageVersion = null;
+let latestPublishedVersionPromise = null;
 function getTellyMcpPackageVersion(startDir) {
     if (cachedPackageVersion) {
         return cachedPackageVersion;
@@ -122,3 +131,122 @@ function getTellyMcpPackageVersion(startDir) {
         return "0.0.0-unknown";
     }
 }
+function parseSemver(value) {
+    const match = value
+        .trim()
+        .match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4]?.split(".").filter(Boolean) ?? [],
+    };
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 && right.length === 0) {
+        return 0;
+    }
+    if (left.length === 0) {
+        return 1;
+    }
+    if (right.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        const leftNumber = /^\d+$/u.test(leftPart) ? Number(leftPart) : null;
+        const rightNumber = /^\d+$/u.test(rightPart) ? Number(rightPart) : null;
+        if (leftNumber !== null && rightNumber !== null) {
+            if (leftNumber !== rightNumber) {
+                return leftNumber > rightNumber ? 1 : -1;
+            }
+            continue;
+        }
+        if (leftNumber !== null) {
+            return -1;
+        }
+        if (rightNumber !== null) {
+            return 1;
+        }
+        if (leftPart !== rightPart) {
+            return leftPart > rightPart ? 1 : -1;
+        }
+    }
+    return 0;
+}
+function comparePackageVersions(leftVersion, rightVersion) {
+    const left = parseSemver(leftVersion);
+    const right = parseSemver(rightVersion);
+    if (!left || !right) {
+        return null;
+    }
+    if (left.major !== right.major) {
+        return left.major > right.major ? 1 : -1;
+    }
+    if (left.minor !== right.minor) {
+        return left.minor > right.minor ? 1 : -1;
+    }
+    if (left.patch !== right.patch) {
+        return left.patch > right.patch ? 1 : -1;
+    }
+    return comparePrerelease(left.prerelease, right.prerelease);
+}
+async function fetchLatestPublishedPackageVersion(timeoutMs = 1500) {
+    if (!latestPublishedVersionPromise) {
+        latestPublishedVersionPromise = (async () => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(exports.TELLYMCP_PACKAGE_NAME)}/latest`, {
+                    method: "GET",
+                    headers: {
+                        accept: "application/json",
+                    },
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    return null;
+                }
+                const parsed = (await response.json());
+                return typeof parsed.version === "string" && parsed.version.trim()
+                    ? parsed.version.trim()
+                    : null;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        })();
+    }
+    return latestPublishedVersionPromise;
+}
+async function detectAvailablePackageUpdate(input) {
+    if (!input.currentVersion.trim() || input.currentVersion === "0.0.0-unknown") {
+        return null;
+    }
+    const latestVersion = await fetchLatestPublishedPackageVersion(input.timeoutMs);
+    if (!latestVersion) {
+        return null;
+    }
+    const comparison = comparePackageVersions(latestVersion, input.currentVersion);
+    if (comparison === null || comparison <= 0) {
+        return null;
+    }
+    return {
+        currentVersion: input.currentVersion,
+        latestVersion,
+    };
+}

package/dist/services/features/telegram-mcp/src/shared/lib/xchangeRecordHints.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIncomingPartnerActionDesc = buildIncomingPartnerActionDesc;
+exports.buildIncomingPartnerTools = buildIncomingPartnerTools;
+exports.buildOutgoingPartnerActionDesc = buildOutgoingPartnerActionDesc;
+exports.buildOutgoingPartnerTools = buildOutgoingPartnerTools;
+exports.buildLocalHandoffActionDesc = buildLocalHandoffActionDesc;
+exports.buildLocalHandoffTools = buildLocalHandoffTools;
+exports.buildIncomingTelegramMessageActionDesc = buildIncomingTelegramMessageActionDesc;
+exports.buildIncomingTelegramMessageTools = buildIncomingTelegramMessageTools;
+exports.detectIncomingTelegramBrowserScreenshotRequest = detectIncomingTelegramBrowserScreenshotRequest;
+function looksLikeBrowserScreenshotRequest(text) {
+    const haystack = text.toLowerCase();
+    return (/\b(browser_open|browser_screenshot|playwright)\b/u.test(haystack) ||
+        /\b(скриншот|screenshot|скрин)\b/u.test(haystack) ||
+        /\bhttps?:\/\/[^\s]+/u.test(haystack));
+}
+function buildIncomingPartnerActionDesc(kind, requiresReply, prefersFileDelivery = false, prefersBrowserScreenshot = false) {
+    if (requiresReply || kind === "question" || kind === "request") {
+        if (prefersBrowserScreenshot) {
+            return "Start with get_xchange_record for the newest partner_note. For a webpage screenshot request, use browser_open and browser_screenshot in this console to create the screenshot artifact, then send that real file back with send_partner_file. Do not stop at analysis, do not just summarize the request, and do not replace the browser workflow with a shell fallback unless the browser tools actually fail. The task is not complete until send_partner_file succeeds. Only after that may you call mark_xchange_record_read.";
+        }
+        if (prefersFileDelivery) {
+            return "Start with get_xchange_record for the newest partner_note, then carry out the requested work in this session and send the result back as a real file with send_partner_file. Do not stop at analysis, do not just summarize the request, and do not paste file contents into send_partner_note. The task is not complete until send_partner_file succeeds. Only after that may you call mark_xchange_record_read.";
+        }
+        return "Start with get_xchange_record for the newest partner_note, then carry out the requested work in this session and send the result back with send_partner_note. Do not stop at analysis and do not just restate the request. The task is not complete until send_partner_note succeeds. Only after that may you call mark_xchange_record_read.";
+    }
+    if (kind === "reply") {
+        return "Read the reply and inspect any returned artifacts. If this reply completes a task that originally came from a human telegram_message in this session, you must forward the final result to the human now. Use notify_telegram for text-only results. If the reply returned a real local artifact or file, use send_file_to_telegram to deliver that file to the human Telegram chat. Do not leave the result only in local xchange records. Only after the human-facing delivery succeeds, or after you have incorporated the reply into a non-human internal task, may you call mark_xchange_record_read.";
+    }
+    if (kind === "handoff") {
+        return "Inspect the attached artifacts and body_text, then continue the task in this session. Reply only if the sender requested confirmation or more work.";
+    }
+    return "Read the shared update and attached artifacts, then continue the task in this session.";
+}
+function buildIncomingPartnerTools(kind, requiresReply, prefersFileDelivery = false, prefersBrowserScreenshot = false) {
+    const tools = ["get_xchange_record"];
+    if (prefersBrowserScreenshot) {
+        tools.push("browser_open", "browser_screenshot");
+    }
+    if (prefersFileDelivery) {
+        tools.push("send_partner_file");
+    }
+    if (requiresReply || kind === "question" || kind === "request") {
+        tools.push("send_partner_note");
+    }
+    if (kind === "handoff" && !tools.includes("send_partner_file")) {
+        tools.push("send_partner_file");
+    }
+    if (kind === "reply") {
+        tools.push("notify_telegram", "send_file_to_telegram");
+    }
+    tools.push("mark_xchange_record_read");
+    return tools;
+}
+function buildOutgoingPartnerActionDesc(kind, requiresReply) {
+    if (requiresReply || kind === "question" || kind === "request") {
+        return "Outgoing collaboration note was sent to the target session. Do not block on sleep, polling, or repeated list_xchange_records calls in the same turn. The target console will be nudged separately and can reply later through the normal xchange path.";
+    }
+    return "Outgoing collaboration note was sent to the target session.";
+}
+function buildOutgoingPartnerTools(kind, requiresReply) {
+    void kind;
+    void requiresReply;
+    return ["get_xchange_record"];
+}
+function buildLocalHandoffActionDesc() {
+    return "Read body_text, inspect the attached local artifacts, and continue the task in this same session.";
+}
+function buildLocalHandoffTools() {
+    return ["get_xchange_record", "mark_xchange_record_read"];
+}
+function buildIncomingTelegramMessageActionDesc(kind, prefersBrowserScreenshot = false) {
+    if (kind === "question" || kind === "request") {
+        if (prefersBrowserScreenshot) {
+            return "Start with get_xchange_record for the newest telegram_message. For a webpage screenshot request, use browser_open and browser_screenshot in this console, and set send_to_telegram=true on browser_screenshot so the PNG goes directly back to the human Telegram chat. Do not stop at analysis, do not just restate the request, do not save the screenshot locally and then search for route metadata, and do not call get_session_context just to deliver the screenshot. The task is not complete until browser_screenshot succeeds with send_to_telegram=true. Only after that may you call mark_xchange_record_read.";
+        }
+        return "Start with get_xchange_record for the newest telegram_message, then carry out the requested work in this session and reply to the human through notify_telegram. Do not stop at analysis and do not just restate the request. The task is not complete until notify_telegram succeeds. Only after that may you call mark_xchange_record_read.";
+    }
+    return "Read the Telegram message and attachments, continue the task in this session, and use notify_telegram only if a human-facing reply is needed.";
+}
+function buildIncomingTelegramMessageTools(kind, prefersBrowserScreenshot = false) {
+    const tools = ["get_xchange_record"];
+    if (prefersBrowserScreenshot && (kind === "question" || kind === "request")) {
+        tools.push("browser_open", "browser_screenshot");
+    }
+    else if (kind === "question" || kind === "request") {
+        tools.push("notify_telegram");
+    }
+    tools.push("mark_xchange_record_read");
+    return tools;
+}
+function detectIncomingTelegramBrowserScreenshotRequest(input) {
+    if (input.kind !== "question" && input.kind !== "request") {
+        return false;
+    }
+    return looksLikeBrowserScreenshotRequest([input.summary ?? "", input.text].join("\n"));
+}