@a1hvdy/cc-openclaw 0.26.4 → 0.26.6

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

@@ -1,868 +0,0 @@
-/**
- * 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 { readFileSync, unlinkSync, mkdirSync, appendFileSync } from 'node:fs';
-import { cleanStalePidFiles } from '../../lib/stale-pid-files.js';
-import { readFile as readFileAsync } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { telegramApi, editTg, bridgeEvent } from './card-renderer.js';
-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';
-import { _logger, setLogger } from './logger.js';
-import { detectSlashCommand } from '../../openai-compat/skill-resolver.js';
-import { TelegramMessageQueue, markDispatchedToTelegram, _sendMessageDedup, _hashPayload, DEDUP_WINDOW_MS, _inputFingerprint, } from './throttle-controller.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
-// TelegramMessageQueue, _sendMessageDedup, _hashPayload, DEDUP_WINDOW_MS,
-// markDispatchedToTelegram, wasDispatchedToTelegram, _inputFingerprint were
-// extracted to throttle-controller.ts in Step 3 of v0.11.0 decomposition.
-// Re-exported below for backward compatibility with sibling modules that
-// import them from live-card.
-export { markDispatchedToTelegram, wasDispatchedToTelegram } from './throttle-controller.js';
-const PAUSE_NOTIFY_COOLDOWN_MS = 60 * 1000;
-// ── M1 helper — wraps options.onThinking so the live card receives a
-// rolling 80-char preview alongside any pre-existing consumer (e.g. the
-// streaming-handler SSE forwarder). Exported for unit tests; not part of
-// the public API surface — callers go through patchedSendMessage.
-export function wrapOnThinking(options, pipeline) {
-    const originalOnThinking = options.onThinking;
-    options.onThinking = (text) => {
-        if (text && typeof pipeline.setThinkingPreview === 'function') {
-            try {
-                pipeline.setThinkingPreview(text.slice(-80));
-            }
-            catch { /* ignore */ }
-        }
-        if (originalOnThinking) {
-            try {
-                originalOnThinking(text);
-            }
-            catch { /* ignore */ }
-        }
-    };
-}
-// ── v0.22.0 M1 helper — lifts v0.20.2 D2 deviation (settle-only refresh).
-// Wraps options.callbacks.onText so per-delta assistant text reaches the
-// pipeline's appendAssistantTextDelta sink (workspace forwards to
-// savvy-card-state.setAssistantText(text,'streaming') — buffered in
-// _pendingAssistantText until messageStop). Preserves any pre-existing
-// onText consumer (SSE forwarder, streaming-handler) — same discipline as
-// wrapOnThinking. Failure-open: if pipeline.appendAssistantTextDelta is
-// absent (older workspace), this is a silent no-op aside from delegating
-// to the original onText. Exported for unit tests.
-export function wrapOnText(options, pipeline) {
-    if (!options.callbacks)
-        options.callbacks = {};
-    const originalOnText = options.callbacks.onText;
-    options.callbacks.onText = (text) => {
-        if (text && typeof pipeline.appendAssistantTextDelta === 'function') {
-            try {
-                pipeline.appendAssistantTextDelta(text);
-            }
-            catch { /* ignore */ }
-        }
-        if (originalOnText) {
-            try {
-                originalOnText(text);
-            }
-            catch { /* ignore */ }
-        }
-    };
-}
-// ── v0.22.0 M5 — dual-bubble layout-mode env gate ────────────────────────
-//
-// CC_OPENCLAW_LIVE_CARD_LAYOUT controls whether bubble #2 (terminal mirror)
-// is emitted alongside the chrome card. Default `chrome_only` preserves
-// exact v0.20.2 behavior with zero regression. Set to `dual_bubble` to
-// enable the terminal mirror — a fenced code-block second message that
-// streams tool-event log lines + rolling assistant text tail.
-//
-// Read once at module load (not per call) so the value is stable across
-// the session — matches the discipline used by RICH_RENDER_ENABLED.
-const DUAL_BUBBLE_LAYOUT_ENABLED = (process.env.CC_OPENCLAW_LIVE_CARD_LAYOUT || 'chrome_only').toLowerCase() === 'dual_bubble';
-/** v0.22.0 M5 — testable getter for the layout-mode resolution.
- *  Returns the active layout: 'chrome_only' | 'dual_bubble'. Reads the
- *  env at call time (NOT cached) so test harnesses can flip the env and
- *  observe the change. The hot-path uses DUAL_BUBBLE_LAYOUT_ENABLED for
- *  one-time resolution; this getter is for tests + diagnostics. */
-export function resolveLiveCardLayout() {
-    return (process.env.CC_OPENCLAW_LIVE_CARD_LAYOUT || 'chrome_only').toLowerCase() === 'dual_bubble'
-        ? 'dual_bubble'
-        : 'chrome_only';
-}
-let _terminalRenderer = null;
-let _terminalRendererLoaded = false;
-function _loadTerminalRenderer() {
-    if (_terminalRendererLoaded)
-        return _terminalRenderer;
-    _terminalRendererLoaded = true;
-    try {
-        const mod = __require('/home/a1xai/.openclaw/workspace/lib/telegram-ux/telegram-renderer.js');
-        if (typeof mod._renderTerminalBubble === 'function') {
-            _terminalRenderer = mod._renderTerminalBubble;
-        }
-    }
-    catch { /* fail open — bubble #2 stays off if workspace lacks renderer */ }
-    return _terminalRenderer;
-}
-/** v0.22.0 M5 — emit bubble #2 if the layout flag is set and the renderer
- *  is available. Fail-open: env unset / `chrome_only` / renderer missing
- *  all silently no-op, preserving zero-regression for the default path.
- *  Callers wire this AFTER updateCard within the same tick so the queue's
- *  shared _cardChain enforces the bubble-ordering invariant. */
-export function maybeEmitDualBubble(state, queue) {
-    if (!DUAL_BUBBLE_LAYOUT_ENABLED)
-        return;
-    if (!queue || typeof queue.updateTerminalBubble !== 'function')
-        return;
-    const renderer = _loadTerminalRenderer();
-    if (!renderer)
-        return;
-    try {
-        const body = renderer(state, {});
-        if (body && body.trim())
-            queue.updateTerminalBubble(body);
-    }
-    catch { /* ignore — bubble #2 must never break bubble #1 */ }
-}
-// ── Telegram Bot API — re-exported from card-renderer.ts for caller compat ─
-export { telegramApi, sendTg, editTg } from './card-renderer.js';
-// ── Per-session Telegram message queue ────────────────────────────────────
-// TelegramMessageQueue moved to throttle-controller.ts in Step 3 of v0.11.0
-// decomposition. Re-exported for callers that import it from live-card.
-export { TelegramMessageQueue } from './throttle-controller.js';
-// ── Event bridge — re-exported from card-renderer.ts ─────────────────────
-export { bridgeEvent } from './card-renderer.js';
-// ── Module-level logger (set at register() time) ──────────────────────────
-// Re-exported from shared logger.ts for backward-compat with siblings that import _logger from here.
-export { _logger, setLogger } from './logger.js';
-// ── 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;
-}
-// ── input dedup fingerprint ───────────────────────────────────────────────
-// _inputFingerprint moved to throttle-controller.ts. Imported above for use
-// in applyPatch's tool-call dedup.
-// ── 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);
-                // v0.22.0 M5 — emit bubble #2 (terminal mirror) in lockstep when
-                // CC_OPENCLAW_LIVE_CARD_LAYOUT=dual_bubble. No-op when env unset
-                // / 'chrome_only' / renderer module didn't load — preserves the
-                // v0.20.2 zero-regression default-path contract.
-                maybeEmitDualBubble(state, queue);
-            },
-            onNewMessage: (text) => {
-                // 2026-05-07: For cc-* sessions, cc-handler delivers the answer directly
-                // via sendDirectReply (see cc-handler.ts after sessionManager.sendMessage).
-                // Skipping pipeline-driven delivery here prevents the doubled answer the
-                // user observed (e.g. "15" appearing twice for /cc 7+8). The pipeline
-                // still owns metadata-card updates (timing, quota, tool count) — only the
-                // assistant-text delivery is suppressed for cc-* sessions.
-                if (sessionType === 'cc')
-                    return;
-                // v0.20.1: escape:true — raw assistant text must be MarkdownV2-escaped
-                // before sending or content punctuation gets corrupted on fallback.
-                // See throttle-controller.ts sendMessage doc + card-renderer.ts
-                // fallback fix for the bug history.
-                queue.sendMessage(text, { escape: true });
-            },
-            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;
-        // v0.5.1: bumped 3 → 8. Long reasoning turns (54+ tools, 5+ min) accumulate
-        // 3 stalls trivially because the stall detector treats per-tool-execution
-        // gaps (60-100s while Bash runs) as model silence. Killing at 3 was killing
-        // turns mid-execution. 8 stalls (~800s of cumulative model-silence) gives
-        // multi-step plans time to complete; the pipeline's natural recovery on tool
-        // output still resets the counter, so most turns won't reach 8.
-        const MAX_STALLS_BEFORE_KILL = 8;
-        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);
-        // M3 (v0.19.1): surface the original /<slash> on the card pill.
-        // Savvy resolved-skill turns get it threaded via options.slashCommand
-        // (extractor → handler → patched sendMessage). CC turns + unresolved
-        // Savvy slashes fall back to detection on the raw message text.
-        try {
-            const optSlash = options.slashCommand;
-            const fallbackSlash = optSlash ? null
-                : (typeof message === 'string' ? detectSlashCommand(message) : null);
-            const slash = optSlash || fallbackSlash;
-            if (slash && typeof pipeline.setSlashCommand === 'function') {
-                pipeline.setSlashCommand(slash);
-            }
-        }
-        catch { /* ignore — pill is cosmetic */ }
-        // 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);
-                // M4 (v0.19.1): mid-stream quota refresh. Engine re-emits the
-                // CLI's `rate_limit_event` envelope; we forward 5h + 7d to the
-                // pipeline immediately so the header `Max N%` updates within
-                // the same tick (vs the existing 30s status-tee poll lag).
-                sessionRef.on('rate_limit_event', (evt) => {
-                    try {
-                        const rli = (evt?.rateLimitInfo || {});
-                        if (rli.five_hour && typeof rli.five_hour.used_percentage === 'number') {
-                            pipeline.setQuotaPercent(rli.five_hour.used_percentage, rli.five_hour.resets_at);
-                        }
-                        if (rli.seven_day && typeof rli.seven_day.used_percentage === 'number') {
-                            pipeline.setQuota7d(rli.seven_day.used_percentage, rli.seven_day.resets_at);
-                        }
-                    }
-                    catch { /* ignore — quota refresh is best-effort */ }
-                });
-            }
-        }
-        catch { /* ignore */ }
-        // Bridge engine thinking-delta stream into the live card. Wraps any
-        // existing options.onThinking (e.g. streaming-handler's SSE forwarder)
-        // so both consumers fire — the SSE thinking-surface must not regress.
-        wrapOnThinking(options, pipeline);
-        // v0.22.0 M1 — bridge engine text_delta stream into the per-delta
-        // pipeline sink (workspace appendAssistantTextDelta → savvy-card-state
-        // setAssistantText(text,'streaming')). Lifts the v0.20.2 D2 deviation
-        // (settle-only refresh) so bubble #2 (terminal mirror, M3) can stream.
-        // Preserves any pre-existing options.callbacks.onText consumer.
-        wrapOnText(options, pipeline);
-        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 (extended 2026-05-06): handle bare-string results too.
-                    // session-manager.sendMessage() returns a STRING (the response text), not an
-                    // object with .output. The original chain (.output → captured) failed when
-                    // session-manager's post-stream coalesce path returns a plain string — so
-                    // resultEntry.text was always empty for fast-turn /cc Q&A and the live card
-                    // showed only metadata with no actual response text.
-                    text: (typeof result === 'string' && result) ||
-                        result?.output ||
-                        result?.text ||
-                        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,
-                };
-                // M2 (v0.19.1): also flow cost through the dedicated setter so
-                // SessionCardState (CC) renders $X.XXXX in footer parity with Savvy.
-                try {
-                    pipeline.setCostUsd?.(stats.costUsd || 0);
-                }
-                catch { /* ignore */ }
-                // M5 (v0.19.1): split cache reads vs new entries so the footer
-                // shows `12K cached · 3K new` instead of dropping cache_creation.
-                try {
-                    const cacheRead = capturedResult?.usage?.cache_read_input_tokens
-                        ?? stats.cachedTokens
-                        ?? 0;
-                    const cacheWrite = capturedResult?.usage?.cache_creation_input_tokens ?? 0;
-                    if (cacheRead > 0 || cacheWrite > 0) {
-                        pipeline.setCacheBreakdown?.(cacheRead, cacheWrite);
-                    }
-                }
-                catch { /* ignore */ }
-                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 _resultText = resultEntry.text || '';
-                // 2026-05-07 fix: dropped `_cardNeverPosted` check from the gate.
-                // The pipeline edits the card with METADATA (quota %, tool count, timing)
-                // even when the assistant text was never delivered to Telegram —
-                // _lastCardEditAt > 0 doesn't imply the answer reached the user.
-                // The original "doubled-greeting" concern is already prevented by
-                // `!queue.messageSent`: pipeline's onNewMessage callback (~line 482)
-                // sets queue.messageSent=true when it delivers via the queue.
-                // So:
-                //   - pipeline delivered text → queue.messageSent=true → skip fallback
-                //   - pipeline only posted metadata → queue.messageSent=false → deliver
-                // Diagnosed 2026-05-07 via stderr instrumentation: gate showed
-                // `cardNeverPosted=false, queueMessageSent=false, gateOpens=false`
-                // while resultText="10" was correctly extracted — proof the gate
-                // was the only blocker on /cc text delivery.
-                // 2026-05-07: cc-* sessions are delivered by cc-handler.ts directly via
-                // sendDirectReply. Fast-turn fallback here would double-fire — skip it
-                // for cc-* and let cc-handler be the sole authoritative delivery path.
-                // Other session types (openai-gw-*, delegated) keep the original path.
-                if (sessionType !== 'cc' && !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 (queue.messageSent gate, non-cc session) 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() {
-    cleanStalePidFiles(STATUS_TEE_DIR, '.json');
-}
-// ── register() ────────────────────────────────────────────────────────────
-/**
- * Register the live-card plugin hooks.
- * Idempotent — subsequent calls are no-ops.
- */
-export function register(api) {
-    setLogger(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