@a1hvdy/cc-openclaw 0.3.2

package/dist/src/channels/telegram/live-card.js

@@ -0,0 +1,916 @@
+/**
+ * telegram live-card — TypeScript port of savvy-claude-code/ux-bridge.js
+ *
+ * Handles:
+ *   - Telegram Bot API HTTP calls (sendTg, editTg, telegramApi)
+ *   - TelegramMessageQueue — serialises per-session card edits
+ *   - bridgeEvent — maps raw stream events to TranscriptEntry shape
+ *   - applyPatch — patches SessionManager.prototype.sendMessage to drive
+ *     TelegramUXPipeline for every Telegram-originating CC session
+ *
+ * Source lines: 1–930 of ux-bridge.js
+ */
+import { request as httpsRequest } from 'node:https';
+import { readFileSync, unlinkSync, readdirSync, mkdirSync, appendFileSync } from 'node:fs';
+import { readFile as readFileAsync } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { createHash } from 'node:crypto';
+import { defaultRegisterGuard } from '../../lib/register-guard.js';
+import { isTestMode } from '../../lib/test-mode.js';
+import { getQuotaPausePct } from '../../lib/config.js';
+import { VENDOR_FILES } from '../../lib/vendor-paths.js';
+const __require = createRequire(import.meta.url);
+// ── Constants ─────────────────────────────────────────────────────────────
+const PLUGIN_TAG = '[cc-openclaw/telegram/live-card]';
+const CC_PLUGIN_PATH = VENDOR_FILES.sessionManager;
+export const UX_MODULE_PATH = '/home/a1xai/.openclaw/workspace/lib/telegram-ux';
+export const VERBOSITY_STORE = '/home/a1xai/.openclaw/workspace/lib/telegram-ux/verbosity-prefs.json';
+const OPENCLAW_CONFIG_PATH = '/home/a1xai/.openclaw/openclaw.json';
+const STATUS_TEE_DIR = '/tmp/openclaw-ux-status';
+const STATUS_POLL_MS = 30000;
+const GPT_POLL_MS = 30000;
+const QUOTA_POLL_MS = 30000;
+// ── Shared mutable state (module-level singletons) ───────────────────────
+export let BOT_TOKEN = '';
+// eslint-disable-next-line prefer-const
+export let minimaxTracker = null;
+export let buttonHandler = null;
+export let nsCommands = null;
+// Active session registry for callback routing: sessionId → { pipeline, queue, name }
+export const activeSessions = new Map();
+// Finished-session grace cache — keeps a session discoverable for button
+// callbacks (Continue / Transcript / Verbose / Model) that arrive AFTER
+// the turn ends. Expires entries after FINISHED_SESSION_TTL_MS.
+export const recentlyFinishedSessions = new Map();
+export const FINISHED_SESSION_TTL_MS = 5 * 60 * 1000;
+// Tier 6: Delegation chain store — tracks Savvy card IDs for CC session linking/cleanup
+export const delegatedCardStore = new Map();
+// F3 — Module-level mirror of the most recent quota fetch.
+export let latestQuotaState = null;
+// F3 — Auto-pause threshold.
+const QUOTA_PAUSE_PCT = getQuotaPausePct();
+// Per-chat cooldown on pause notifications
+const _pauseNotifiedAt = new Map(); // chatId → timestamp
+/**
+ * Defensive in-flight dedup for patchedSendMessage. The doubled-greeting bug
+ * surfaces as two separate sendMessage invocations for the same model output
+ * (each constructs its own TelegramMessageQueue, defeating queue-level
+ * gating). Until the upstream double-call root cause is identified, we
+ * short-circuit duplicate (chatId, payload-hash) pairs that arrive
+ * within DEDUP_WINDOW_MS of each other. Logs a single WARN per duplicate to
+ * collect evidence for the next-round investigation.
+ *
+ * Important: keyed on chatId (NOT sessionName) because the upstream double
+ * call uses two different session names for the same Telegram-chat output.
+ * The chatId is the stable invariant that identifies "where this message
+ * is going" regardless of which session generated it.
+ */
+const _sendMessageDedup = new Map(); // chatId → entry
+const DEDUP_WINDOW_MS = 3000;
+function _hashPayload(message) {
+    let payload;
+    try {
+        payload = typeof message === 'string' ? message : JSON.stringify(message);
+    }
+    catch {
+        payload = String(message);
+    }
+    // 12-char sha1 prefix is collision-safe within a 2s window for our payload sizes
+    return createHash('sha1').update(payload.slice(0, 4096)).digest('hex').slice(0, 12);
+}
+/**
+ * Shared cross-handler dedup. Any handler dispatching to Telegram should
+ * (a) mark via `markDispatchedToTelegram(chatId, payload)` and (b) check via
+ * `wasDispatchedToTelegram(chatId, payload)` to short-circuit duplicates.
+ *
+ * Used to bridge the gap between cc-openclaw's patched SessionManager.send
+ * path and the gateway's native ACP message_sending path — both can fire
+ * for the same agent reply, producing the doubled-greeting on /new.
+ */
+export function markDispatchedToTelegram(chatId, payload) {
+    if (!chatId)
+        return;
+    const hash = _hashPayload(payload);
+    _sendMessageDedup.set(chatId, { hash, expiresAt: Date.now() + DEDUP_WINDOW_MS });
+}
+export function wasDispatchedToTelegram(chatId, payload) {
+    if (!chatId)
+        return false;
+    const existing = _sendMessageDedup.get(chatId);
+    if (!existing)
+        return false;
+    if (existing.expiresAt <= Date.now()) {
+        _sendMessageDedup.delete(chatId);
+        return false;
+    }
+    return existing.hash === _hashPayload(payload);
+}
+const PAUSE_NOTIFY_COOLDOWN_MS = 60 * 1000;
+// ── Telegram Bot API ──────────────────────────────────────────────────────
+export function telegramApi(method, params) {
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify(params);
+        const options = {
+            hostname: 'api.telegram.org',
+            path: `/bot${BOT_TOKEN}/${method}`,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+        };
+        const req = httpsRequest(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch {
+                    resolve({ ok: false, description: 'JSON parse error' });
+                }
+            });
+        });
+        req.on('error', (err) => reject(err));
+        req.setTimeout(10_000, () => {
+            req.destroy(new Error('Telegram API timeout'));
+        });
+        req.write(body);
+        req.end();
+    });
+}
+/** Send a Telegram message. Tries MarkdownV2 first, falls back to plain text. */
+export async function sendTg(chatId, text, threadId, replyMarkup, replyToMessageId) {
+    try {
+        const base = { chat_id: chatId, disable_web_page_preview: true };
+        if (threadId)
+            base.message_thread_id = Number(threadId);
+        if (replyMarkup)
+            base.reply_markup = replyMarkup;
+        if (replyToMessageId)
+            base.reply_to_message_id = Number(replyToMessageId);
+        const res = await telegramApi('sendMessage', {
+            ...base,
+            text,
+            parse_mode: 'MarkdownV2',
+        });
+        if (res.ok)
+            return res;
+        const plain = text.replace(/[_*[\]()~`>#+\-=|{}.!\\]/g, '');
+        return telegramApi('sendMessage', {
+            ...base,
+            text: plain || 'Session update',
+        });
+    }
+    catch {
+        return { ok: false };
+    }
+}
+/** Edit a Telegram message. Tries MarkdownV2 first, falls back to plain text. */
+export async function editTg(chatId, messageId, text, replyMarkup) {
+    // TODO(P2): refine logger reference — currently uses module-level logger
+    try {
+        const params = {
+            chat_id: chatId,
+            message_id: messageId,
+            text,
+            parse_mode: 'MarkdownV2',
+            disable_web_page_preview: true,
+        };
+        if (replyMarkup)
+            params.reply_markup = replyMarkup;
+        const res = await telegramApi('editMessageText', params);
+        if (!res.ok && (res.error_code === 429 || res.description?.includes('Too Many Requests'))) {
+            const retryAfterSec = res.parameters?.retry_after || 5;
+            const waitMs = Math.min(retryAfterSec * 1000, 30000);
+            _logger.warn(`${PLUGIN_TAG} editTg 429 — waiting ${waitMs}ms`);
+            await new Promise(r => setTimeout(r, waitMs));
+            const retry = await telegramApi('editMessageText', params);
+            if (retry.ok)
+                return retry;
+        }
+        if (res.ok)
+            return res;
+        const plain = text.replace(/[_*[\]()~`>#+\-=|{}.!\\]/g, '');
+        const fallback = {
+            chat_id: chatId,
+            message_id: messageId,
+            text: plain || 'Session update',
+            disable_web_page_preview: true,
+        };
+        if (replyMarkup)
+            fallback.reply_markup = replyMarkup;
+        return telegramApi('editMessageText', fallback);
+    }
+    catch {
+        return { ok: false };
+    }
+}
+// ── Per-session Telegram message queue ────────────────────────────────────
+export class TelegramMessageQueue {
+    chatId;
+    threadId;
+    cardMessageId;
+    _replyToMessageId;
+    /**
+     * Sticky flag — set true the first time `sendMessage()` is called for this
+     * queue instance. Lets the fast-turn fallback in `applyPatch()` detect that
+     * a new message was already dispatched by the pipeline's `onNewMessage`
+     * callback and avoid double-firing. Bug context: 2026-04-29 doubled-greeting
+     * on `/new` was caused by both the pipeline AND the fallback emitting the
+     * same model output as separate Telegram messages.
+     */
+    messageSent;
+    _cardChain;
+    _msgChain;
+    constructor(chatId, threadId, existingCardMessageId, replyToMessageId) {
+        this.chatId = chatId;
+        this.threadId = threadId;
+        this._replyToMessageId = replyToMessageId || null;
+        this.cardMessageId = existingCardMessageId || null;
+        this.messageSent = false;
+        this._cardChain = Promise.resolve();
+        this._msgChain = Promise.resolve();
+    }
+    /** Send or edit the session card. */
+    updateCard(text, replyMarkup) {
+        this._cardChain = this._cardChain.then(async () => {
+            if (this.cardMessageId) {
+                await editTg(this.chatId, this.cardMessageId, text, replyMarkup);
+            }
+            else {
+                const res = await sendTg(this.chatId, text, this.threadId, replyMarkup, this._replyToMessageId);
+                if (res.ok && res.result?.message_id) {
+                    this.cardMessageId = res.result.message_id;
+                    this._replyToMessageId = null;
+                }
+            }
+        }).catch(e => _logger.error(`${PLUGIN_TAG} card update error: ${e.message}`));
+    }
+    /** Send a standalone message (error alert, completion summary). */
+    sendMessage(text) {
+        this.messageSent = true;
+        this._msgChain = this._msgChain.then(async () => {
+            await sendTg(this.chatId, text, this.threadId);
+        }).catch(e => _logger.error(`${PLUGIN_TAG} message send error: ${e.message}`));
+    }
+}
+export function bridgeEvent(event) {
+    const ts = new Date().toISOString();
+    if (event.type === 'tool_use') {
+        const parentToolUseId = event.parent_tool_use_id ||
+            event.tool?.parent_tool_use_id ||
+            event.parentToolUseId ||
+            '';
+        return {
+            kind: 'tool_call',
+            ts,
+            name: event.tool?.name || 'Unknown',
+            input: event.tool?.input || {},
+            toolUseId: event.id || event.tool_use_id || '',
+            parentToolUseId,
+        };
+    }
+    if (event.type === 'tool_result') {
+        return {
+            kind: 'tool_result',
+            ts,
+            toolUseId: event.tool_use_id || event.id || '',
+            toolName: event.tool_name || event.tool?.name || undefined,
+            content: event.content || event.output || '',
+            isError: Boolean(event.is_error || event.error),
+            parentToolUseId: event.parent_tool_use_id || event.parentToolUseId || '',
+        };
+    }
+    if (event.type === 'text') {
+        return {
+            kind: 'assistant',
+            ts,
+            text: event.result || '',
+            delta: true,
+        };
+    }
+    return null;
+}
+// ── Module-level logger (set at register() time) ──────────────────────────
+export let _logger = console;
+// ── UX module + patch state ───────────────────────────────────────────────
+let uxModule = null;
+let patchApplied = false;
+const PATCH_MARKER = Symbol.for('telegram-ux-bridge:patched');
+export function loadUxModule() {
+    if (!uxModule) {
+        uxModule = __require(UX_MODULE_PATH);
+    }
+    if (!buttonHandler) {
+        try {
+            const { ButtonHandler, NS_COMMANDS } = __require(`${UX_MODULE_PATH}/button-handler`);
+            buttonHandler = new ButtonHandler();
+            nsCommands = NS_COMMANDS || null;
+        }
+        catch { /* button-handler not available — buttons disabled */ }
+    }
+    return uxModule;
+}
+function _inputFingerprint(input) {
+    if (!input || typeof input !== 'object')
+        return { size: 0, sig: '' };
+    const inp = input;
+    const size = (Object.keys(inp).length +
+        (inp.command?.length || 0) +
+        (inp.new_string?.length || 0) +
+        (inp.old_string?.length || 0) +
+        (inp.content?.length || 0) +
+        (inp.pattern?.length || 0) +
+        (inp.query?.length || 0) +
+        (inp.prompt?.length || 0));
+    const fp = (s) => s ? `${s.slice(0, 16)}\x02${s.slice(-16)}` : '';
+    const sig = fp(inp.command) + '\x01' +
+        fp(inp.old_string) + '\x01' +
+        fp(inp.new_string) + '\x01' +
+        fp(inp.content) + '\x01' +
+        fp(inp.pattern) + '\x01' +
+        fp(inp.query) + '\x01' +
+        fp(inp.prompt);
+    return { size, sig };
+}
+// ── applyPatch ────────────────────────────────────────────────────────────
+export async function applyPatch() {
+    if (patchApplied)
+        return;
+    patchApplied = true;
+    let SessionManager;
+    try {
+        const mod = await import(CC_PLUGIN_PATH);
+        const Cls = (mod.SessionManager || mod.default?.SessionManager);
+        SessionManager = Cls;
+    }
+    catch (err) {
+        _logger.error(`${PLUGIN_TAG} Cannot import SessionManager: ${err.message}`);
+        return;
+    }
+    if (!SessionManager) {
+        _logger.error(`${PLUGIN_TAG} SessionManager class not found in module`);
+        return;
+    }
+    try {
+        loadUxModule();
+    }
+    catch (err) {
+        _logger.error(`${PLUGIN_TAG} Cannot load telegram-ux module: ${err.message}`);
+        return;
+    }
+    const original = SessionManager.prototype.sendMessage;
+    if (!original) {
+        _logger.error(`${PLUGIN_TAG} sendMessage not found on SessionManager.prototype`);
+        return;
+    }
+    if (original[PATCH_MARKER]) {
+        _logger.warn(`${PLUGIN_TAG} sendMessage already patched — skipping to prevent message duplication`);
+        return;
+    }
+    // TODO(P2): `this` context is the SessionManager instance at runtime — complex shape
+    SessionManager.prototype.sendMessage = async function patchedSendMessage(name, message, options = {}) {
+        const __PERF_KEY = Symbol.for('claude-local:perf-timing');
+        const __perfSendStart = performance.now();
+        let __perfFirstEventAbsMs = null;
+        const __perfStore = globalThis[__PERF_KEY]
+            = globalThis[__PERF_KEY] || new Map();
+        const __perfBareKey = name.startsWith('openai-') ? name.slice(7) : name;
+        {
+            const prev = __perfStore.get(name) || __perfStore.get(__perfBareKey) || {};
+            __perfStore.set(name, { ...prev, sendMessageStartAbsMs: __perfSendStart });
+        }
+        let chatId = options.telegramChatId || '';
+        let threadId = options.telegramThreadId || undefined;
+        if (!chatId) {
+            const UX_META = Symbol.for('telegram-ux-bridge:metadata');
+            const shared = globalThis[UX_META]?.get(name);
+            if (shared) {
+                chatId = shared.chatId || '';
+                threadId = shared.threadId || undefined;
+                globalThis[UX_META].delete(name);
+                if (chatId) {
+                    _logger.info(`${PLUGIN_TAG} Resolved telegram metadata from global store for session "${name}": chat=${chatId} thread=${threadId || 'none'}`);
+                }
+            }
+        }
+        if (!BOT_TOKEN || !chatId) {
+            return original.call(this, name, message, options);
+        }
+        // ── In-flight dedup ─────────────────────────────────────────────────────
+        // Doubled-greeting defensive guard: if patchedSendMessage is invoked twice
+        // within DEDUP_WINDOW_MS for the same (chatId, payload), short-circuit the
+        // duplicate so it doesn't reach Telegram. Keyed on chatId because the
+        // upstream double-call uses two different session names for the same
+        // chat-bound output — sessionName is unstable, chatId is invariant.
+        // Logs the first duplicate at WARN to surface the upstream double-call.
+        {
+            const _payloadHash = _hashPayload(message);
+            const _existing = _sendMessageDedup.get(chatId);
+            const _now = Date.now();
+            if (_existing && _existing.hash === _payloadHash && _existing.expiresAt > _now) {
+                _logger.warn(`${PLUGIN_TAG} Duplicate patchedSendMessage detected within ${DEDUP_WINDOW_MS}ms for chat=${chatId} session=${name} payloadHash=${_payloadHash} — short-circuiting (upstream double-call evidence)`);
+                return; // no queue, no telegramApi call
+            }
+            _sendMessageDedup.set(chatId, { hash: _payloadHash, expiresAt: _now + DEDUP_WINDOW_MS });
+            // Cheap GC: prune entries whose window has elapsed (keeps map small).
+            if (_sendMessageDedup.size > 64) {
+                for (const [k, v] of _sendMessageDedup) {
+                    if (v.expiresAt <= _now)
+                        _sendMessageDedup.delete(k);
+                }
+            }
+        }
+        // Mark this (chatId, message) so the state-machine's message_sending
+        // hook can cancel the native ACP dispatcher when it also fires for
+        // the same payload — that's the doubled-greeting cross-path bug.
+        markDispatchedToTelegram(chatId, message);
+        // F3 — Quota auto-pause
+        if (QUOTA_PAUSE_PCT > 0 && QUOTA_PAUSE_PCT <= 100) {
+            const pct7d = latestQuotaState?.sevenDay?.usedPercent;
+            if (typeof pct7d === 'number' && pct7d >= QUOTA_PAUSE_PCT) {
+                const lastNotif = _pauseNotifiedAt.get(chatId) || 0;
+                if (Date.now() - lastNotif > PAUSE_NOTIFY_COOLDOWN_MS) {
+                    _pauseNotifiedAt.set(chatId, Date.now());
+                    const note = `⏸ Weekly plan quota at ${pct7d}% — dispatch paused (threshold ${QUOTA_PAUSE_PCT}%). Set OPENCLAW_QUOTA_PAUSE_PCT=100 to disable.`;
+                    telegramApi('sendMessage', {
+                        chat_id: chatId,
+                        text: note,
+                        ...(threadId ? { message_thread_id: Number(threadId) } : {}),
+                    }).catch(() => { });
+                }
+                _logger.warn(`${PLUGIN_TAG} Quota pause: 7d=${pct7d}% threshold=${QUOTA_PAUSE_PCT}% name=${name}`);
+                const err = new Error(`quota-paused: 7d ${pct7d}% ≥ ${QUOTA_PAUSE_PCT}%`);
+                err.code = 'QUOTA_PAUSED';
+                throw err;
+            }
+        }
+        const { TelegramUXPipeline } = loadUxModule();
+        const ackMessageId = options.telegramAckMessageId || null;
+        const queue = new TelegramMessageQueue(chatId, threadId, ackMessageId);
+        const delegatedInfo = delegatedCardStore.get(name);
+        if (delegatedInfo && !ackMessageId) {
+            queue._replyToMessageId = delegatedInfo.cardMessageId;
+        }
+        let model = 'claude';
+        let permissionMode = null;
+        try {
+            const managed = this._getSession?.(name);
+            model = (managed?.config?.model || managed?.session?.options?.model || 'claude');
+            permissionMode = managed?.config?.permissionMode || null;
+        }
+        catch { /* ignore */ }
+        const sessionType = name.startsWith('cc-') ? 'cc'
+            : name.startsWith('openai-') ? 'savvy'
+                : 'delegated';
+        let sessionRef = null;
+        try {
+            sessionRef = this._getSession?.(name)?.session || null;
+        }
+        catch { /* session may not exist yet */ }
+        const pipeline = new TelegramUXPipeline({
+            sessionName: name,
+            model,
+            chatKey: `telegram:${chatId}`,
+            verbosityStorePath: VERBOSITY_STORE,
+            editIntervalMs: 5000,
+            onCardUpdate: (text, state) => {
+                const markup = buttonHandler ? buttonHandler.buildButtons(state, name) : undefined;
+                queue.updateCard(text, markup);
+            },
+            onNewMessage: (text) => queue.sendMessage(text),
+            livenessCheck: () => {
+                const pid = sessionRef?.pid || this._getSession?.(name)?.session?.pid;
+                if (!pid)
+                    return true;
+                try {
+                    process.kill(pid, 0);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+        pipeline.start();
+        // Stall auto-kill
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const sessionMgr = this;
+        let consecutiveStalls = 0;
+        const MAX_STALLS_BEFORE_KILL = 3;
+        const origHandleStall = pipeline._handleStall.bind(pipeline);
+        const origHandleRecovery = pipeline._handleStallRecovery.bind(pipeline);
+        pipeline._handleStall = (idleMs) => {
+            consecutiveStalls++;
+            origHandleStall(idleMs);
+            const alive = pipeline._livenessCheck ? pipeline._livenessCheck() : true;
+            if (!alive || consecutiveStalls >= MAX_STALLS_BEFORE_KILL) {
+                _logger.warn(`${PLUGIN_TAG} Auto-killing stalled session "${name}" (alive=${alive}, stalls=${consecutiveStalls})`);
+                queue.sendMessage(`⚠️ Session auto-stopped: ${!alive ? 'process exited' : `${consecutiveStalls} consecutive stalls with no activity`}`);
+                try {
+                    sessionMgr.stopSession(name);
+                }
+                catch (e) {
+                    _logger.warn(`${PLUGIN_TAG} Auto-kill stopSession error: ${e.message}`);
+                }
+            }
+        };
+        pipeline._handleStallRecovery = () => {
+            consecutiveStalls = 0;
+            origHandleRecovery();
+        };
+        activeSessions.set(name, { pipeline, queue, name });
+        if (permissionMode)
+            pipeline.setPermissionMode(permissionMode);
+        pipeline.setSessionType(sessionType);
+        // Status file polling
+        let statusPollTimer = null;
+        let resolvedStatusPid = null;
+        const _pollStatus = async () => {
+            try {
+                if (!sessionRef) {
+                    sessionRef = this._getSession?.(name)?.session || null;
+                }
+                const stats = sessionRef?.getStats?.() || sessionRef?.stats;
+                if (stats) {
+                    if (typeof stats.tokensIn === 'number') {
+                        pipeline.setTokenUsage(stats.tokensIn, stats.tokensOut || 0);
+                    }
+                    if (typeof stats.contextPercent === 'number' && stats.contextPercent > 0) {
+                        pipeline.setContextPercent(Math.round(stats.contextPercent));
+                    }
+                    if (typeof stats.cachedTokens === 'number' && stats.cachedTokens > 0) {
+                        const totalIn = (stats.tokensIn || 0) + (stats.cachedTokens || 0);
+                        const pct = totalIn > 0 ? (stats.cachedTokens / totalIn) * 100 : null;
+                        pipeline.setCachedTokens(stats.cachedTokens, pct);
+                    }
+                }
+                const sessionModel = sessionRef?.options?.model;
+                if (sessionModel)
+                    pipeline.setModel(sessionModel);
+                if (minimaxTracker) {
+                    const mmUsage = minimaxTracker.getUsage();
+                    if (mmUsage.used > 0) {
+                        pipeline.setMiniMaxUsage(mmUsage);
+                    }
+                }
+            }
+            catch { /* session not ready yet */ }
+            try {
+                if (!resolvedStatusPid) {
+                    resolvedStatusPid = sessionRef?.pid || this._getSession?.(name)?.session?.pid || null;
+                }
+                if (!resolvedStatusPid) {
+                    statusPollTimer = setTimeout(_pollStatus, STATUS_POLL_MS);
+                    return;
+                }
+                const statusFile = `${STATUS_TEE_DIR}/${resolvedStatusPid}.json`;
+                const raw = await readFileAsync(statusFile, 'utf8');
+                const data = JSON.parse(raw);
+                const ctxPct = data?.context_window?.used_percentage;
+                if (typeof ctxPct === 'number')
+                    pipeline.setContextPercent(Math.round(ctxPct));
+                const rateLimits = data?.rate_limits;
+                const quotaPct = rateLimits?.five_hour?.used_percentage;
+                const quotaReset = rateLimits?.five_hour?.resets_at;
+                if (typeof quotaPct === 'number')
+                    pipeline.setQuotaPercent(Math.round(quotaPct), quotaReset || null);
+                const quotaPct7d = rateLimits?.seven_day?.used_percentage;
+                const quotaReset7d = rateLimits?.seven_day?.resets_at;
+                if (typeof quotaPct7d === 'number')
+                    pipeline.setQuota7d(Math.round(quotaPct7d), quotaReset7d || null);
+                const modelData = data?.model;
+                const modelName = modelData?.display_name || modelData?.model_id;
+                if (modelName)
+                    pipeline.setModel(modelName);
+                const ctxSize = data?.context_window?.context_window_size;
+                if (typeof ctxSize === 'number' && ctxSize > 0)
+                    pipeline.setContextWindowSize(ctxSize);
+                const usage = data?.context_window?.current_usage;
+                const inTok = usage?.input_tokens;
+                const outTok = usage?.output_tokens;
+                if (typeof inTok === 'number' && typeof outTok === 'number')
+                    pipeline.setTokenUsage(inTok, outTok);
+            }
+            catch { /* status file doesn't exist or parse error — normal for pipe mode */ }
+            statusPollTimer = setTimeout(_pollStatus, STATUS_POLL_MS);
+        };
+        statusPollTimer = setTimeout(_pollStatus, STATUS_POLL_MS);
+        // GPT/Codex usage polling
+        let gptPollTimer = null;
+        try {
+            const _ux = loadUxModule();
+            const { getCodexUsage } = (_ux.getCodexUsage
+                ? _ux
+                : __require(`${UX_MODULE_PATH}/codex-usage`));
+            const pollGpt = async () => {
+                try {
+                    const usage = await getCodexUsage();
+                    if (usage)
+                        pipeline.setGptUsage(usage);
+                }
+                catch { /* ignore */ }
+            };
+            const initialUsage = await getCodexUsage().catch(() => null);
+            if (initialUsage)
+                pipeline.setGptUsage(initialUsage);
+            const lastUsedMs = initialUsage?.lastUsed || 0;
+            if (Date.now() - lastUsedMs < 24 * 60 * 60 * 1000) {
+                gptPollTimer = setInterval(pollGpt, GPT_POLL_MS);
+            }
+        }
+        catch { /* codex-usage module not available — skip */ }
+        // Anthropic OAuth quota polling
+        let quotaPollTimer = null;
+        try {
+            const { QuotaFetcher } = __require(`${UX_MODULE_PATH}/quota-fetcher`);
+            const quotaFetcher = new QuotaFetcher();
+            quotaFetcher.startPolling(QUOTA_POLL_MS, (quota) => {
+                latestQuotaState = quota;
+                if (quota.fiveHour && quota.fiveHour.usedPercent != null) {
+                    pipeline.setQuotaPercent(quota.fiveHour.usedPercent, quota.fiveHour.resetsAt);
+                }
+                if (quota.sevenDay && quota.sevenDay.usedPercent != null) {
+                    pipeline.setQuota7d(quota.sevenDay.usedPercent, quota.sevenDay.resetsAt);
+                }
+            });
+            quotaPollTimer = quotaFetcher;
+        }
+        catch { /* quota-fetcher module not available — skip */ }
+        let capturedResult = null;
+        const resultListener = (event) => { capturedResult = event; };
+        try {
+            sessionRef = this._getSession?.(name)?.session || null;
+            if (sessionRef?.on) {
+                sessionRef.on('result', resultListener);
+            }
+        }
+        catch { /* ignore */ }
+        const originalOnEvent = options.onEvent;
+        const toolUseInputSize = new Map();
+        options.onEvent = (event) => {
+            if (event.type === 'tool_use') {
+                const id = event.id || event.tool_use_id || '';
+                if (id) {
+                    const curr = _inputFingerprint(event.tool?.input);
+                    const prev = toolUseInputSize.get(id);
+                    if (prev && curr.size <= prev.size && curr.sig === prev.sig) {
+                        if (originalOnEvent) {
+                            try {
+                                originalOnEvent(event);
+                            }
+                            catch { /* ignore */ }
+                        }
+                        return;
+                    }
+                    toolUseInputSize.set(id, curr);
+                }
+            }
+            if (__perfFirstEventAbsMs == null) {
+                __perfFirstEventAbsMs = performance.now();
+            }
+            const entry = bridgeEvent(event);
+            if (entry) {
+                pipeline.processTranscriptEntry(entry);
+            }
+            if (originalOnEvent) {
+                try {
+                    originalOnEvent(event);
+                }
+                catch { /* ignore */ }
+            }
+        };
+        try {
+            const result = await original.call(this, name, message, options);
+            try {
+                const stats = sessionRef?.stats || {};
+                const resultEntry = {
+                    kind: 'result',
+                    ts: new Date().toISOString(),
+                    // Fallback chain matches savvy's ux-bridge.js: result.output → capturedResult.result → ''
+                    text: result?.output ||
+                        capturedResult?.result ||
+                        '',
+                    inputTokens: capturedResult?.usage?.input_tokens || stats.tokensIn || 0,
+                    outputTokens: capturedResult?.usage?.output_tokens || stats.tokensOut || 0,
+                    cachedTokens: capturedResult?.usage?.cache_read_input_tokens || stats.cachedTokens || 0,
+                    costUsd: stats.costUsd || 0,
+                };
+                pipeline.finish(resultEntry);
+                // Fast-turn fallback: when the pipeline's gate suppresses card posting
+                // (no tools, <20s thinking, no files/errors), pipeline.finish() returns
+                // silently and the ack message is never edited. For plain Q&A turns
+                // (/cc how r u), this would silently drop the reply. If the card was
+                // never posted AND no message was sent through the queue AND we have
+                // an ack to edit AND a text result, deliver the result directly via
+                // queue.sendMessage() — which edits the ack in-place since
+                // cardMessageId is set. Closes a real bug surfaced in production
+                // 2026-04-27.
+                //
+                // Bug fix 2026-04-29: also gate on `queue.messageSent` to avoid
+                // double-firing when the pipeline's `onNewMessage` callback already
+                // delivered the result. Without this gate, fast turns like the
+                // /new greeting were dispatched twice (pipeline+fallback) — observed
+                // as two `[telegram] sendMessage ok` calls within ~350ms for one
+                // model output.
+                const _cardNeverPosted = pipeline._lastCardEditAt === 0;
+                const _resultText = resultEntry.text || '';
+                if (_cardNeverPosted && !queue.messageSent && ackMessageId && _resultText) {
+                    // queue.sendMessage is fire-and-forget (returns void); errors are swallowed by the queue's own _msgChain.
+                    queue.sendMessage(_resultText);
+                    _logger.info(`${PLUGIN_TAG} fast-turn fallback: delivered result via queue.sendMessage (card gate suppressed) session=${name}`);
+                }
+                try {
+                    const state = pipeline._cardState?.getState?.() || {};
+                    const metricsDir = '/home/a1xai/.openclaw/workspace/memory';
+                    mkdirSync(metricsDir, { recursive: true });
+                    const __perfEnd = performance.now();
+                    const __perfEntry = __perfStore.get(name) || __perfStore.get(__perfBareKey) || {};
+                    const perfFields = {
+                        perfRoutePatchMs: __perfEntry.routePatchMs ?? null,
+                        perfRouteToSendMs: __perfEntry.routePatchEndAbsMs != null
+                            ? Math.round(__perfSendStart - __perfEntry.routePatchEndAbsMs)
+                            : null,
+                        perfTtftMs: __perfFirstEventAbsMs != null
+                            ? Math.round(__perfFirstEventAbsMs - __perfSendStart)
+                            : null,
+                        perfSendMessageMs: Math.round(__perfEnd - __perfSendStart),
+                        perfTurnTotalMs: __perfEntry.routePatchEndAbsMs != null
+                            ? Math.round(__perfEnd - (__perfEntry.routePatchEndAbsMs - (__perfEntry.routePatchMs || 0)))
+                            : null,
+                    };
+                    if (perfFields.perfRoutePatchMs != null) {
+                        perfFields.perfRoutePatchMs = Math.round(perfFields.perfRoutePatchMs);
+                    }
+                    __perfStore.delete(name);
+                    __perfStore.delete(__perfBareKey);
+                    const metricsLine = JSON.stringify({
+                        ts: new Date().toISOString(),
+                        sessionName: name,
+                        chatId: chatId || null,
+                        durationMs: state.elapsedMs || 0,
+                        toolCount: state.toolCount || 0,
+                        toolsByCategory: state.toolSummary || {},
+                        errorCount: state.errorCount || 0,
+                        stallCount: state.stallCount || 0,
+                        thinkingMs: state.thinkingMs || 0,
+                        filesModifiedCount: (state.filesModified || []).length,
+                        subagentCount: (state.subagents || []).length,
+                        inputTokens: resultEntry.inputTokens,
+                        outputTokens: resultEntry.outputTokens,
+                        cachedTokens: resultEntry.cachedTokens,
+                        status: state.status || 'done',
+                        ...perfFields,
+                    }) + '\n';
+                    setImmediate(() => {
+                        try {
+                            appendFileSync(`${metricsDir}/session-metrics.jsonl`, metricsLine);
+                        }
+                        catch { /* metrics advisory — non-fatal */ }
+                    });
+                }
+                catch { /* metrics are advisory — never block on failure */ }
+            }
+            catch {
+                pipeline.finish(null);
+            }
+            return result;
+        }
+        catch (err) {
+            pipeline.abort();
+            throw err;
+        }
+        finally {
+            if (statusPollTimer)
+                clearTimeout(statusPollTimer);
+            if (gptPollTimer)
+                clearInterval(gptPollTimer);
+            if (quotaPollTimer)
+                quotaPollTimer.stopPolling();
+            if (resolvedStatusPid) {
+                try {
+                    unlinkSync(`${STATUS_TEE_DIR}/${resolvedStatusPid}.json`);
+                }
+                catch { /* ignore */ }
+            }
+            if (sessionRef?.removeListener) {
+                sessionRef.removeListener('result', resultListener);
+            }
+            activeSessions.delete(name);
+            recentlyFinishedSessions.set(name, { pipeline, queue, name, finishedAt: Date.now() });
+            setTimeout(() => {
+                const e = recentlyFinishedSessions.get(name);
+                if (e && Date.now() - e.finishedAt >= FINISHED_SESSION_TTL_MS) {
+                    recentlyFinishedSessions.delete(name);
+                }
+            }, FINISHED_SESSION_TTL_MS + 100);
+            const delegatedRef = delegatedCardStore.get(name);
+            if (delegatedRef) {
+                delegatedCardStore.delete(name);
+                const collapsedText = '➡️ *Savvy* — delegated \\(complete\\)';
+                editTg(delegatedRef.chatId, delegatedRef.cardMessageId, collapsedText, { inline_keyboard: [] })
+                    .catch(e => _logger.warn(`${PLUGIN_TAG} delegated card collapse failed: ${e.message}`));
+                setTimeout(() => {
+                    telegramApi('deleteMessage', {
+                        chat_id: delegatedRef.chatId,
+                        message_id: delegatedRef.cardMessageId,
+                    }).catch(() => { });
+                }, 5 * 60 * 1000);
+            }
+        }
+    };
+    SessionManager.prototype.sendMessage[PATCH_MARKER] = true;
+    _logger.info(`${PLUGIN_TAG} SessionManager.sendMessage patched — UX pipeline active`);
+}
+// ── Stale status file cleanup ─────────────────────────────────────────────
+export function cleanStaleStatusFiles() {
+    try {
+        const files = readdirSync(STATUS_TEE_DIR);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const pid = parseInt(file.replace('.json', ''), 10);
+            if (isNaN(pid))
+                continue;
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                try {
+                    unlinkSync(`${STATUS_TEE_DIR}/${file}`);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* directory doesn't exist — nothing to clean */ }
+}
+// ── register() ────────────────────────────────────────────────────────────
+/**
+ * Register the live-card plugin hooks.
+ * Idempotent — subsequent calls are no-ops.
+ */
+export function register(api) {
+    _logger = api.logger || console;
+    defaultRegisterGuard.guard('channels/telegram/live-card', api, () => {
+        // Read bot token from api.config first, then filesystem fallback
+        try {
+            const cfg = api.config || {};
+            const tgChannels = cfg.channels?.telegram;
+            if (tgChannels?.accounts) {
+                const acctKey = tgChannels.defaultAccount || 'default';
+                const acct = tgChannels.accounts[acctKey] || {};
+                BOT_TOKEN = acct.botToken || '';
+            }
+        }
+        catch { /* fall through to filesystem */ }
+        if (!BOT_TOKEN) {
+            try {
+                const raw = readFileSync(OPENCLAW_CONFIG_PATH, 'utf8');
+                const ocConfig = JSON.parse(raw);
+                const tgChannels = ocConfig.channels?.telegram;
+                if (tgChannels?.accounts) {
+                    const acctKey = tgChannels.defaultAccount || 'default';
+                    const acct = tgChannels.accounts[acctKey] || {};
+                    BOT_TOKEN = acct.botToken || '';
+                }
+                if (BOT_TOKEN) {
+                    _logger.info(`${PLUGIN_TAG} Telegram credentials loaded from ${OPENCLAW_CONFIG_PATH}`);
+                }
+            }
+            catch (err) {
+                _logger.warn(`${PLUGIN_TAG} Filesystem config fallback failed: ${err.message}`);
+            }
+        }
+        if (!BOT_TOKEN) {
+            _logger.warn(`${PLUGIN_TAG} No Telegram bot token found — plugin will be inactive`);
+        }
+        if (api.registerService) {
+            api.registerService({
+                id: 'telegram-ux-bridge',
+                start: async () => {
+                    _logger.info(`${PLUGIN_TAG} Initialising via service lifecycle...`);
+                    await applyPatch();
+                },
+                stop: () => {
+                    _logger.info(`${PLUGIN_TAG} Stopped`);
+                },
+            });
+        }
+        if (BOT_TOKEN) {
+            if (isTestMode()) {
+                _logger.info(`${PLUGIN_TAG} TEST_MODE=1 — skipping eager SessionManager.sendMessage patch and stale status file cleanup`);
+            }
+            else {
+                _logger.info(`${PLUGIN_TAG} Eagerly applying SessionManager patch...`);
+                cleanStaleStatusFiles();
+                applyPatch().catch((err) => {
+                    _logger.error(`${PLUGIN_TAG} Eager patch failed: ${err.message}`);
+                });
+            }
+        }
+        _logger.info(`${PLUGIN_TAG} live-card hooks registered`);
+    }); // end defaultRegisterGuard.guard
+}
+//# sourceMappingURL=live-card.js.map