@a1hvdy/cc-openclaw 0.29.0 → 0.31.0

package/dist/src/channels/telegram-mirror/burst-accumulator.d.ts

@@ -1,96 +0,0 @@
-/**
- * src/channels/telegram-mirror/burst-accumulator.ts — v0.25.0 M8.
- *
- * Per-chat 5-second settle window for non-slash inbound messages. When
- * the user fires multiple message bubbles within 5s of each other, the
- * accumulator concatenates them into one user-message payload (joined by
- * "\n\n") before delivery to the engine. A gap > 5s flushes the prior
- * buffer immediately and starts a new one.
- *
- * Decision: ADR-007 — 5s is the empirical saddle point. <3s gaps are
- * almost always related thoughts; >8s gaps are almost always new turns.
- * 5s matches the WARMUP_COOLDOWN_MS in typing-prefetch.ts (consistency).
- *
- * Routing responsibility lives in the inbound dispatcher (later milestone):
- *   • Slash messages bypass this class — dispatched immediately via
- *     dispatchCommand (commands.ts).
- *   • Compose-active chats bypass this class — drafts go to ComposeBuffer
- *     (compose-buffer.ts). M7 takes priority over M8 per ADR-007.
- *   • Everything else flows through submit() here.
- *
- * The flush flow has TWO triggers:
- *   1. A new submit() that arrives AFTER the settle window — that submit
- *      returns the prior buffer in `flushed` and starts a fresh buffer.
- *   2. A periodic flushIfReady() check that runs on a timer when no new
- *      inbound has arrived since the window opened.
- *
- * Tests inject a deterministic clock; production passes Date.now.
- */
-export interface BurstAccumulatorOptions {
-    /** Settle window in milliseconds (default 5000 per ADR-007). */
-    settleMs?: number;
-    /** Injectable clock for tests; defaults to Date.now. */
-    now?: () => number;
-    /** Custom separator between concatenated drafts (default "\n\n"). */
-    separator?: string;
-}
-export interface SubmitResult {
-    /**
-     * When the new submit() arrives AFTER the prior buffer's settle window,
-     * the prior buffer is returned here for immediate delivery; the new
-     * message starts a fresh buffer in its place. Undefined otherwise.
-     */
-    flushed?: string;
-}
-export declare class BurstAccumulator {
-    private readonly sessions;
-    private readonly settleMs;
-    private readonly now;
-    private readonly separator;
-    constructor(opts?: BurstAccumulatorOptions);
-    /**
-     * Submit a non-slash inbound message. Returns `flushed` populated when
-     * the prior buffer for the chat had timed out and this submit forced
-     * its flush; in that case the new message starts a fresh buffer.
-     *
-     * The returned `flushed` payload is the only value the caller delivers
-     * to the engine — the new message itself stays buffered for at least
-     * `settleMs` more, so it gets a chance to coalesce with follow-ups.
-     */
-    submit(chatId: string, text: string): SubmitResult;
-    /**
-     * Periodic check — when the settle window has elapsed without any new
-     * inbound, returns the buffered payload and clears the session. When
-     * the window has NOT yet elapsed, returns undefined and leaves the
-     * buffer intact. Returns undefined for chats without an active buffer.
-     *
-     * Production wiring: call from a 1Hz interval timer per known chatId
-     * (or from the inbound dispatcher's idle-tick).
-     */
-    flushIfReady(chatId: string): string | undefined;
-    /**
-     * Force-flush the buffer for a chat regardless of timing. Used when an
-     * explicit signal arrives that the current buffer must deliver now —
-     * e.g. a slash command was typed (its dispatcher flushes burst first,
-     * then routes the slash, so the bursted text reaches the engine before
-     * the slash response).
-     */
-    flushNow(chatId: string): string | undefined;
-    /**
-     * True when a buffer exists for the chat (regardless of settle state).
-     * Used by the inbound dispatcher to decide whether a slash arrival
-     * should trigger flushNow before routing.
-     */
-    hasBuffer(chatId: string): boolean;
-    /**
-     * Number of drafts currently buffered for the chat. Useful for status
-     * surfaces and for tests asserting the buffer state.
-     */
-    draftCount(chatId: string): number;
-    /**
-     * Clear all sessions. Test helper.
-     */
-    clear(): void;
-    private fresh;
-    private format;
-}

package/dist/src/channels/telegram-mirror/callback-mapping.d.ts

@@ -1,61 +0,0 @@
-/**
- * src/channels/telegram-mirror/callback-mapping.ts — v0.25.0 M3.
- *
- * ADR-004 — Telegram's callback_data is capped at 64 bytes UTF-8. For
- * payloads larger than that (most action+slug combinations are), the bot
- * writes a short opaque base36 id into callback_data and stashes the real
- * payload here. TTL prevents unbounded memory growth as users tap through
- * keyboards or never tap at all.
- *
- * Default TTL is 10 minutes per ADR-004 monitoring signal (callback miss
- * rate > 2% in soak → revisit TTL). The class accepts an injectable clock
- * so tests can fast-forward without setTimeout games.
- *
- * No I/O, no global state. Each subsystem that hands out callback_data
- * owns its own CallbackMap instance — keeps ownership boundaries clean
- * for M4 (per-command), M9 (plan keyboards), M11 (cost subview).
- */
-export interface CallbackMapOptions {
-    /** TTL in milliseconds (default 10 minutes per ADR-004). */
-    ttlMs?: number;
-    /** Injectable clock for tests; defaults to Date.now. */
-    now?: () => number;
-    /** Length of the opaque id string (default 8 base36 chars ≈ 41 bits entropy). */
-    idLength?: number;
-}
-export declare class CallbackMap {
-    private readonly entries;
-    private readonly ttlMs;
-    private readonly now;
-    private readonly idLength;
-    constructor(opts?: CallbackMapOptions);
-    /**
-     * Allocate a fresh opaque id and stash the payload behind it. Returns the
-     * id, which fits in a Telegram callback_data field with room to spare.
-     * Idempotent only at the data-shape level — calling create() with the
-     * same payload twice produces two distinct ids.
-     */
-    create(payload: unknown): string;
-    /**
-     * Resolve a callback id to its stashed payload. Returns undefined if the
-     * id was never minted OR if it has expired since. Stale entries are
-     * dropped lazily on access — no background timer needed.
-     */
-    get(id: string): unknown | undefined;
-    /**
-     * Manually evict an id (e.g., one-shot Approve/Reject buttons after the
-     * user taps once). Returns true if an entry was deleted.
-     */
-    delete(id: string): boolean;
-    /**
-     * Current entry count (after pruning expired). Useful for monitoring
-     * and the 2% callback-miss-rate signal in soak.
-     */
-    size(): number;
-    /**
-     * Drop everything. Test helper; production code never calls this.
-     */
-    clear(): void;
-    private prune;
-    private randomId;
-}

package/dist/src/channels/telegram-mirror/card-renderer.d.ts

@@ -1,68 +0,0 @@
-/**
- * src/channels/telegram-mirror/card-renderer.ts — v0.25.0 M2.
- *
- * Pure-function renderer: Turn (from state-machine.ts) → message body string
- * suitable for sendMessage / editMessageText. Telegram-API HTTP wiring
- * (sendTg / editTg) lands in a later milestone alongside the dispatch path
- * — M2's exit criterion is just "render a single turn (working → done)",
- * which is satisfied by this pure function.
- *
- * Aesthetic: terminal-mimic per ADR-001. Header glyph ("▶" working,
- * "✓" done) + tool call list (each prefixed with status glyph) + assistant
- * text. Compact enough to fit in a single Telegram message bubble.
- *
- * Tests live at tests/channels/telegram-mirror/m2-render-pipeline.test.ts.
- */
-import type { Turn, ToolCallRecord } from './state-machine.js';
-import type { CardMeta } from './card-state.js';
-export declare function toolDiffBlock(tc: ToolCallRecord): string;
-/**
- * v0.27.5 — pick a syntax-highlight language for a tool's RESULT block so the
- * card colors output the way the terminal does. Bash/shell → 'bash'; file tools
- * → inferred from the `file_path` extension via EXT_LANG. Unknown → undefined
- * (renders classless, no regression — never guess a language we can't justify).
- */
-export declare function langForTool(tc: ToolCallRecord): string | undefined;
-/**
- * Format one tool-call line for inclusion in the rendered card body.
- *   "✓ Bash · ls -la"
- *   "… Read · src/index.ts"
- *   "✗ Edit · …error glyph at left"
- */
-/**
- * Tool-type emoji icon (v0.26.4 styling). Pure unicode — renders in Telegram's
- * plain-text mode (the card currently sends as plain because unescaped
- * MarkdownV2 specials fail the parse; emoji/dividers work regardless). Unknown
- * tools get a neutral marker.
- */
-export declare function toolIcon(name: string): string;
-export declare function renderToolLine(tc: ToolCallRecord): string;
-/**
- * Render the thinking block (M6). Each line of the thinking text is
- * prefixed with "> " to read as a block quote in plain-text Telegram
- * bubbles — clearly visually distinct from the assistant text below it
- * without depending on MarkdownV2 escapes. Empty thinking returns ''.
- */
-export declare function renderThinkingBlock(thinkingText: string): string;
-export declare function renderTurn(turn: Turn, meta?: CardMeta): string;
-/**
- * A render action — abstraction the dispatch layer (added in a later
- * milestone) consumes. M2 doesn't dispatch; it just builds the action so
- * tests can assert against the planned message lifecycle.
- *
- *   - 'send' on turn start (no prior messageId)
- *   - 'edit' on every subsequent state mutation
- */
-export interface RenderAction {
-    type: 'send' | 'edit';
-    chatId: string;
-    text: string;
-    /** Defined only when type === 'edit'. */
-    messageId?: number;
-}
-/**
- * Decide whether the current turn snapshot should be sent (first render)
- * or edited (subsequent renders). The dispatcher tracks the (chatId →
- * messageId) map; this function just produces the action shape.
- */
-export declare function planRenderAction(turn: Turn, knownMessageId: number | undefined): RenderAction;

package/dist/src/channels/telegram-mirror/card-state.d.ts

@@ -1,83 +0,0 @@
-/**
- * src/channels/telegram-mirror/card-state.ts — v0.26.1.
- *
- * Module-scope shared state for the active Telegram mirror cards. Extracted
- * from inbound-handler.ts so the openai-compat handlers (which see the real
- * tool_use / text stream from the Claude subprocess) can push events into
- * the live card without a cross-channel event bus.
- *
- * Single source of truth: one Map<chatId, CardEntry>. Both inbound-handler
- * (writer on before_dispatch / reply_dispatch) and turn-bridge (writer from
- * streaming + non-streaming handlers) read+write here.
- *
- * ── v0.26.1 live-mirror fix: globalThis singleton ──────────────────────────
- * A plain `new Map()` at module scope is only a singleton if every importer
- * shares the same module INSTANCE. That assumption breaks here: the inbound
- * handler is loaded via the plugin's register() graph, but the openai-compat
- * handlers are loaded via cwd-patch's EAGER `await import(<abs path>)` of the
- * embedded server (session-bootstrap/cwd-patch.ts:906/336). When the same
- * file is reached through two different load roots, Node can hold TWO module
- * instances → two different Maps. The card the inbound handler registers
- * (so the user sees "▶ Working" and later "✓ Done") then lives in instance A,
- * while turn-bridge's pushToolUse/pushAssistantText run against instance B's
- * empty Map → every push silently no-ops. That is the exact "card frame
- * renders, body never fills" symptom that survived v0.25.7/0.25.9/0.26.0.
- *
- * Fix: anchor the Map on globalThis under a Symbol.for() key so ALL instances
- * resolve to ONE Map regardless of how the module was loaded. This mirrors
- * the codebase's existing cross-instance pattern (cwd-patch's
- * `Symbol.for('telegram-ux-bridge:metadata')` UX_META store). Harmless if the
- * single-instance assumption already held — it's the same one Map either way.
- */
-import type { TurnStateMachine } from './state-machine.js';
-/**
- * Per-card status metadata for the CC-CLI-style status line (v0.26.2). Every
- * field is OPTIONAL and rendered only when genuinely available (no-fake-data
- * rule). The inbound handler creates the card with empty meta; the openai-compat
- * handlers fill it in via turn-bridge.setCardMeta() once the model turn starts
- * (model, bypass) and completes (contextPercent). Quota is read at render time.
- */
-export interface CardMeta {
-    /** Resolved model id, e.g. "claude-opus-4-7" (handler `model` param). */
-    model?: string;
-    /** True when the session runs permissionMode 'bypassPermissions'. */
-    bypassPermissions?: boolean;
-    /** Context-window usage % from getStatus().stats.contextPercent (M2). */
-    contextPercent?: number;
-    /** Plan/quota usage % (status-tee maxPercent) — set at render time (M2). */
-    quotaPercent?: number;
-    /** Quota window reset, Unix epoch seconds (status-tee resetsAt) (M2). */
-    quotaResetsAt?: number;
-    /**
-     * Latest todo list captured from the agent's TodoWrite tool call (M4). Real
-     * data — the only one of rules/hooks/todos reachable from the plugin (rules &
-     * hooks live in the subprocess and are not exposed). Empty/absent → omitted.
-     */
-    todos?: Array<{
-        content: string;
-        status: string;
-    }>;
-}
-export interface CardEntry {
-    /** Telegram message_id of the editable card. */
-    messageId: number;
-    /** Per-turn state machine (one Turn per chat at a time). */
-    sm: TurnStateMachine;
-    /** Telegram message_thread_id when the chat is a forum/group topic. */
-    threadId?: number;
-    /** CC-CLI status-line metadata (v0.26.2). Filled progressively per turn. */
-    meta?: CardMeta;
-}
-/**
- * chatId → active card. Cleared at model-turn end by
- * turn-bridge.finalizeActiveCards(). Process-global singleton (see header) so
- * the inbound handler and the openai-compat handlers share ONE Map even across
- * module-instance splits.
- */
-export declare const cardState: Map<string, CardEntry>;
-/**
- * Compact card-state summary for the turn-bridge push logs and the
- * openai-compat handler entry log — the permanent live-mirror success-gate
- * signal (cards>0 during a turn means events are reaching the active card).
- */
-export declare function cardStateDebug(): string;

package/dist/src/channels/telegram-mirror/commands.d.ts

@@ -1,183 +0,0 @@
-/**
- * src/channels/telegram-mirror/commands.ts — v0.25.0 M4.
- *
- * Top-7 phone-tier slash commands per PRP §5 M4:
- *   /sessions /new <slug> /stop /status /compact /cost /rewind
- *
- * Each handler is a pure function returning a CommandResult — a list of
- * Telegram API actions the dispatch layer consumes. No I/O happens here
- * beyond reading session-registry (which itself isolates I/O behind an
- * env-overridable path for tests).
- *
- * G-2 resolution (2026-05-19): per-message inline keyboards + typed-form
- * — no persistent ReplyKeyboardMarkup. /sessions and /cost have an
- * inline-keyboard form; the rest are text-only.
- *
- * Decision refs:
- *   • ADR-003 — slug registry is the canonical source for /sessions, /new,
- *     /stop, /status.
- *   • ADR-004 — callback_data slots come from the per-handler CallbackMap.
- *   • ADR-008 — failure handlers (M12) consume CommandResult.actions[].
- *
- * Out of scope for M4 (per "no premature resolution"):
- *   • Actually spawning / killing claude subprocesses (M5+ wiring).
- *   • Real quota numbers in /cost — uses QuotaReader stub (M11 wires real).
- *   • Threshold notifications / 95% pause button (M11).
- *   • Plan attachment via sendDocument (M9).
- */
-import { CallbackMap } from './callback-mapping.js';
-import { type SessionState, type InlineButton } from './sessions-keyboard.js';
-import { type QuotaReader } from './quota-reader.js';
-import type { ComposeBuffer } from './compose-buffer.js';
-/**
- * Discriminated union of Telegram API actions a command may emit.
- * Maps 1:1 to the test mock layer at tests/.../__mocks__/telegram-api.ts.
- */
-export type TelegramAction = {
-    type: 'sendMessage';
-    chat_id: string | number;
-    text: string;
-    reply_markup?: {
-        inline_keyboard: InlineButton[][];
-    };
-    parse_mode?: 'MarkdownV2';
-} | {
-    type: 'editMessageText';
-    chat_id: string | number;
-    message_id: number;
-    text: string;
-    reply_markup?: {
-        inline_keyboard: InlineButton[][];
-    };
-    parse_mode?: 'MarkdownV2';
-} | {
-    type: 'sendDocument';
-    chat_id: string | number;
-    filename: string;
-    content: string;
-    caption?: string;
-    reply_markup?: {
-        inline_keyboard: InlineButton[][];
-    };
-};
-export interface CommandContext {
-    chatId: string | number;
-    args: string[];
-    callbackMap: CallbackMap;
-    /** Optional state lookup for status-rich rows; defaults all entries to 'idle'. */
-    stateLookup?: (slug: string) => SessionState;
-    /** Optional quota reader for /cost; defaults to stubQuotaReader. */
-    quotaReader?: QuotaReader;
-    /** Optional clock for deterministic last-activity tests. */
-    now?: number;
-    /** Required for /compose and /send (M7); other handlers ignore. */
-    composeBuffer?: ComposeBuffer;
-}
-export interface CommandResult {
-    actions: TelegramAction[];
-    /**
-     * When the command produces user-message content destined for the
-     * engine (currently only /send after /compose), the concatenated
-     * payload appears here. M5+ engine bridging consumes this field to
-     * feed openai-compat as a single user message. Absent when the command
-     * is purely a UI surface (most handlers).
-     */
-    delivery?: {
-        payload: string;
-    };
-}
-/**
- * Tiny parser. Telegram slash messages look like "/cmd arg1 arg2" — split
- * on whitespace, drop the leading '/', strip any "@botname" suffix.
- * Returns undefined for non-slash input.
- */
-export interface ParsedSlash {
-    cmd: string;
-    args: string[];
-}
-export declare function parseSlash(text: string): ParsedSlash | undefined;
-/**
- * v0.28.0 — `/sessions` is now a `claude -r`-style picker over the REAL Claude
- * Code sessions. It mirrors `~/.claude/projects/**` (the store every `claude`
- * subprocess — terminal or cco-spawned — writes to), so one list spans both
- * surfaces. Each row shows the session's own ai-title (name) + last-prompt
- * (description); tapping resumes it immediately via the globalThis resume
- * bridge. Buttons use the proven `ccmirror:` callback path (buildResumeButton).
- *
- * The previous registry-backed keyboard (buildSessionsKeyboard / enrichRows)
- * is retired here: its "switch" callbacks were never wired (M4 stub), and the
- * slug registry only ever saw cco-Telegram sessions, not terminal ones.
- */
-export declare function handleSessions(ctx: CommandContext): CommandResult;
-export declare function handleNew(ctx: CommandContext): CommandResult;
-export declare function handleStop(ctx: CommandContext): CommandResult;
-export declare function handleStatus(ctx: CommandContext): CommandResult;
-export declare function handleCompact(ctx: CommandContext): CommandResult;
-export declare function handleCost(ctx: CommandContext): CommandResult;
-export declare function handleRewind(ctx: CommandContext): CommandResult;
-/**
- * v0.27.7 — /clear claims the command so it stops leaking to the LLM as plain
- * text (the bug: before this, /clear wasn't in COMMAND_HANDLERS, so the inbound
- * router forwarded it verbatim to Claude instead of handling it).
- *
- * It does NOT fake an in-place context reset. The running session's lifecycle +
- * resume linkage live in the command-router (activeSessions, meta.claudeSessionId)
- * and the engine — not this bookkeeping registry — so a pure mirror handler has
- * no honest lever to wipe context (the same D-6 constraint behind /compact and
- * /rewind being CLI-only). So /clear points to the paths that actually work: a
- * fresh session via /new <slug>, or an in-place wipe via /clear in the CLI.
- */
-export declare function handleClear(ctx: CommandContext): CommandResult;
-/**
- * Open a compose session for the chat. M7 — drafts append until /send.
- * Returns a force_reply prompt so Telegram nudges the user into reply mode.
- */
-export declare function handleCompose(ctx: CommandContext): CommandResult;
-/**
- * Commit the active compose buffer. Returns the concatenated payload via
- * CommandResult.delivery for the engine bridge to consume. If no session
- * is active, returns a friendly error message.
- */
-export declare function handleSend(ctx: CommandContext): CommandResult;
-/**
- * Cancel the active compose buffer without sending. Useful when the user
- * starts composing then changes their mind.
- */
-export declare function handleCancel(ctx: CommandContext): CommandResult;
-/**
- * Surface a Y/N inline keyboard so A1 records opened-laptop-today for
- * the soak instrumentation. Idempotency is enforced by SoakLogger
- * downstream — handler always emits the keyboard and lets the callback
- * resolver call recordLaptopCheck().
- */
-export declare function handleSoakCheck(ctx: CommandContext): CommandResult;
-/**
- * Full user-facing command catalogue, used by /help. The TOP_7 are the
- * phone-tier set synced to Telegram's command menu; the workflow extras
- * (compose/send/cancel) + help round out what the mirror actually claims.
- */
-export declare const ALL_COMMANDS: ReadonlyArray<{
-    command: string;
-    description: string;
-}>;
-/**
- * /help — list the mirror's commands. Discoverability close for gap #6: the 11
- * commands were previously invisible. Notes the passthrough so the user knows
- * any other slash (custom skills like /pregoal) or plain text reaches Claude.
- * HTML-safe content (only the intentional <b> tag); sendTg renders parse_mode:HTML.
- */
-export declare function handleHelp(ctx: CommandContext): CommandResult;
-export type CommandHandler = (ctx: CommandContext) => CommandResult;
-export declare const COMMAND_HANDLERS: Record<string, CommandHandler>;
-/**
- * Telegram bot commands list — declarative source for M5's setMyCommands sync.
- */
-export declare const TOP_7_COMMANDS: ReadonlyArray<{
-    command: string;
-    description: string;
-}>;
-/**
- * Route a parsed slash command to its handler. Returns undefined for
- * unknown commands so the caller can fall back to "unknown command" UX.
- */
-export declare function dispatchCommand(parsed: ParsedSlash, ctxBase: Omit<CommandContext, 'args'>): CommandResult | undefined;

package/dist/src/channels/telegram-mirror/compose-buffer.d.ts

@@ -1,71 +0,0 @@
-/**
- * src/channels/telegram-mirror/compose-buffer.ts — v0.25.0 M7.
- *
- * Per-chat buffer of draft messages between /compose and /send. The
- * dispatch layer feeds non-slash inbound messages here when a chat is in
- * compose mode; /send commits the buffer to one concatenated payload that
- * M5+ engine bridging delivers to openai-compat as a single user message.
- *
- * Decision: ADR-007 — the 5-second rapid-burst window (M8) is a SEPARATE
- * concatenation path. /compose is the explicit, user-controlled buffer
- * with no time limit (within reason); rapid-burst is the implicit window
- * for accidental double-taps. M7's compose buffer takes priority over
- * the M8 burst handler when a compose session is active.
- *
- * Timeout exists purely as a safety valve — a compose session that's
- * been idle for > timeoutMs is considered abandoned and silently cleared
- * on the next interaction. Default 30 minutes; tests inject shorter.
- */
-export interface ComposeBufferOptions {
-    /** Injectable clock for tests; defaults to Date.now. */
-    now?: () => number;
-    /** Idle-session timeout in milliseconds (default 30 minutes). */
-    timeoutMs?: number;
-}
-export declare class ComposeBuffer {
-    private readonly sessions;
-    private readonly now;
-    private readonly timeoutMs;
-    constructor(opts?: ComposeBufferOptions);
-    /**
-     * Open a compose session for the chat. If a session is already open it
-     * is replaced — the user is restarting the buffer intentionally.
-     */
-    start(chatId: string): void;
-    /**
-     * Append a draft message to the active compose session. Returns true
-     * when the message was buffered, false when no session was open (or the
-     * session timed out and was discarded). Callers use the return to
-     * decide whether to route the message through the regular inbound path
-     * instead.
-     */
-    append(chatId: string, text: string): boolean;
-    /**
-     * Commit the active compose session. Returns the concatenated payload
-     * (drafts joined by `separator`) and clears the session, or undefined
-     * when no session was open / the session timed out. Default separator
-     * is "\n\n" — produces natural paragraph breaks between drafts.
-     */
-    commit(chatId: string, separator?: string): string | undefined;
-    /**
-     * Drop the compose session without committing. Returns true iff a
-     * session existed.
-     */
-    cancel(chatId: string): boolean;
-    /**
-     * Lazy-expiring isActive. Returns true only when a non-stale session
-     * exists; stale sessions are dropped on the call.
-     */
-    isActive(chatId: string): boolean;
-    /**
-     * Number of drafts buffered (without committing). Useful for /compose
-     * status surfaces.
-     */
-    draftCount(chatId: string): number;
-    /**
-     * Inspect drafts without committing — used for preview UX. Returns a
-     * copy so callers can't mutate internal state.
-     */
-    peek(chatId: string): string[];
-    private isExpired;
-}

package/dist/src/channels/telegram-mirror/cost-views.d.ts

@@ -1,58 +0,0 @@
-/**
- * src/channels/telegram-mirror/cost-views.ts — v0.25.0 M11.
- *
- * Renderers for the /cost detail / per-day inline-keyboard subviews +
- * threshold-notification message builder.
- *
- * Decision refs:
- *   • ADR-004 — callback_data for the 🛑 Pause-now button at the 95%
- *     notification uses CallbackMap.
- *   • PRP M11 — 95% notification gets the pause button; 70/90 are
- *     advisory text-only.
- *
- * Pure functions; tests assert directly against the strings + actions
- * they produce.
- */
-import type { CallbackMap } from './callback-mapping.js';
-import type { TelegramAction } from './commands.js';
-import type { QuotaSnapshot } from './quota-reader.js';
-import { type QuotaSnapshot as StatusTeeQuotaSnapshot } from '../../lib/status-tee-reader.js';
-import type { QuotaReader } from './quota-reader.js';
-/**
- * Render the rich /cost detail subview. Includes:
- *   • Header line with Max 20x percent and weekly burn.
- *   • Top sessions list (up to 5) ranked by tokens.
- *   • Empty-state friendly message when no data.
- */
-export declare function renderCostDetail(snap: QuotaSnapshot): string;
-/**
- * Render the per-day rollup subview. Up to the last 7 days, newest first.
- */
-export declare function renderCostPerDay(snap: QuotaSnapshot): string;
-/**
- * Build a threshold-crossed notification message. The 95% variant ships
- * a 🛑 Pause-now button; the lower thresholds are text-only.
- */
-export declare function buildThresholdNotification(opts: {
-    chatId: string | number;
-    threshold: number;
-    callbackMap: CallbackMap;
-}): TelegramAction;
-/**
- * Adapter that wires the mirror's QuotaReader contract to the existing
- * status-tee-reader.ts on disk. Reads the latest JSON snapshot under
- * ~/.openclaw/workspace/memory/status-tee-* and projects it into the
- * mirror's summary shape.
- *
- * Limitations vs. mirror's full QuotaSnapshot:
- *   • status-tee carries fiveHour + sevenDay windows; we project the
- *     sevenDay percent into maxPercent (falling back to fiveHour when
- *     missing).
- *   • status-tee does not carry weeklyBurn USD, topSessions, or
- *     perDayRollup. Those fields land at zero / empty until a future
- *     PRP (likely v0.26.0) extends status-tee's emit format.
- *
- * Returns a stub-shaped snapshot when status-tee data is missing or
- * stale, so callers always get a usable object.
- */
-export declare function createStatusTeeQuotaReader(reader?: () => StatusTeeQuotaSnapshot | null): QuotaReader;

package/dist/src/channels/telegram-mirror/failure/callback-data-overflow.d.ts

@@ -1,21 +0,0 @@
-/**
- * failure/callback-data-overflow.ts — v0.25.0 M12.
- *
- * Mode: callback-data-overflow. Defensive — should never fire because
- * every callback_data slot routes through CallbackMap (ADR-004) and the
- * 8-char base36 ids fit in 8 UTF-8 bytes. If a future regression bypasses
- * the map and a literal payload > 64 bytes makes it to Telegram, the API
- * rejects with 400 BUTTON_DATA_INVALID; this handler surfaces the
- * recovery instruction. The PRP frames the response shape as
- * "never present at UX layer" — when it does, the mode is broken,
- * not the user's input.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface CallbackDataOverflowInfo {
-    /** The offending button label, for diagnostics. */
-    buttonLabel?: string;
-    /** The byte length that exceeded the cap. */
-    payloadBytes?: number;
-}
-export declare const handle: FailureHandler<CallbackDataOverflowInfo>;

package/dist/src/channels/telegram-mirror/failure/gateway-down.d.ts

@@ -1,15 +0,0 @@
-/**
- * failure/gateway-down.ts — v0.25.0 M12.
- *
- * Mode: gateway-down. Surfaces when the openclaw-gateway is unresponsive
- * (heartbeat aged out OR explicit ping failure). Piggybacks on the
- * existing `.openclaw/gateway-supervisor-restart-handoff.json` heartbeat
- * mechanism per PRP M12 wiring.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface GatewayDownInfo {
-    /** Seconds since the last heartbeat was observed. */
-    lastSeenAgoSec?: number;
-}
-export declare const handle: FailureHandler<GatewayDownInfo>;