@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

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>;

package/dist/src/channels/telegram-mirror/failure/in-flight-conflict.d.ts

@@ -1,15 +0,0 @@
-/**
- * failure/in-flight-conflict.ts — v0.25.0 M12.
- *
- * Mode: in-flight-conflict. User typed (or tapped) while a turn was
- * already in progress for the chat. The mirror queues the message
- * rather than dropping it; this surface lets the user know to expect
- * a follow-up reply once the current turn completes.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface InFlightConflictInfo {
-    /** Approximate position in the queue (1-indexed). */
-    queuePos?: number;
-}
-export declare const handle: FailureHandler<InFlightConflictInfo>;

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

@@ -1,23 +0,0 @@
-/**
- * src/channels/telegram-mirror/failure/index.ts — v0.25.0 M12 barrel.
- *
- * Exports every failure-mode handler + metadata so the dispatcher (and
- * M13's chaos test) can iterate the canonical list. Keeping each mode
- * in its own module per ADR-008; this barrel is the dispatch surface.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export type { FailureContext, FailureHandler, FailureModuleMeta, Severity } from './types.js';
-export interface FailureModule {
-    META: FailureModuleMeta;
-    handle: FailureHandler<unknown>;
-}
-/**
- * Canonical 8-mode list per PRP M12. ADR-008 mandates one row per mode;
- * the order here mirrors that ordering in the PRP/brief tables.
- */
-export declare const FAILURE_MODULES: ReadonlyArray<FailureModule>;
-/**
- * Lookup map keyed by mode id. The dispatcher / chaos harness uses this
- * to fire a handler by name.
- */
-export declare const FAILURE_BY_MODE: Readonly<Record<string, FailureModule>>;

package/dist/src/channels/telegram-mirror/failure/model-5xx.d.ts

@@ -1,16 +0,0 @@
-/**
- * failure/model-5xx.ts — v0.25.0 M12.
- *
- * Mode: model-5xx. Upstream model returned a 500-class HTTP status.
- * Transient by definition — the surface is advisory, the retry is
- * automatic at the engine layer.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface Model5xxInfo {
-    /** The exact HTTP status (e.g. 502, 503, 504). */
-    status?: number;
-    /** Attempt number (1-indexed). */
-    attempt?: number;
-}
-export declare const handle: FailureHandler<Model5xxInfo>;

package/dist/src/channels/telegram-mirror/failure/network-blip.d.ts

@@ -1,17 +0,0 @@
-/**
- * failure/network-blip.ts — v0.25.0 M12.
- *
- * Mode: network-blip. Transient network error (DNS, TCP reset, ETIMEDOUT)
- * on an upstream call. Auto-retried at the transport layer; this surface
- * is advisory only and fires on the first user-observable blip per turn
- * so the chat doesn't drown in retry chatter.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface NetworkBlipInfo {
-    /** Error code surfaced by the transport (e.g. "ETIMEDOUT", "ECONNRESET"). */
-    code?: string;
-    /** Endpoint that blipped (for diagnostics). */
-    endpoint?: string;
-}
-export declare const handle: FailureHandler<NetworkBlipInfo>;

package/dist/src/channels/telegram-mirror/failure/pool-exhausted-fallback.d.ts

@@ -1,15 +0,0 @@
-/**
- * failure/pool-exhausted-fallback.ts — v0.25.0 M12.
- *
- * Mode: pool-exhausted-fallback. The SubprocessPool (v0.16+ / M1
- * v0.24.0) is saturated — incoming turn falls back to direct CLI spawn.
- * The user surface is informational only; the engine completes the turn
- * regardless. Tracked so soak instrumentation can flag if it fires often.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface PoolExhaustedInfo {
-    /** Number of in-flight pool slots at the time of fallback. */
-    poolSize?: number;
-}
-export declare const handle: FailureHandler<PoolExhaustedInfo>;

package/dist/src/channels/telegram-mirror/failure/rate-limit.d.ts

@@ -1,16 +0,0 @@
-/**
- * failure/rate-limit.ts — v0.25.0 M12.
- *
- * Mode: rate-limit. Telegram bot API 429 or Anthropic 429 hit. Caller
- * supplies the upstream retry-after hint when known; default surface is
- * a transparent back-off advisory without prompting user action.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface RateLimitInfo {
-    /** Source of the limit — "telegram" or "anthropic". */
-    source?: 'telegram' | 'anthropic';
-    /** Server-advertised retry-after seconds, when available. */
-    retryAfterSec?: number;
-}
-export declare const handle: FailureHandler<RateLimitInfo>;

package/dist/src/channels/telegram-mirror/failure/returning-after-24h.d.ts

@@ -1,14 +0,0 @@
-/**
- * failure/returning-after-24h.ts — v0.25.0 M12.
- *
- * Mode: returning-after-24h. The chat last had inbound activity more
- * than 24 hours ago. Surfaces a friendly welcome-back + status hint so
- * the user can decide whether to resume vs start fresh.
- */
-import type { FailureHandler, FailureModuleMeta } from './types.js';
-export declare const META: FailureModuleMeta;
-export interface ReturningAfter24hInfo {
-    /** Hours since the last inbound activity, rounded to nearest integer. */
-    hoursAgo?: number;
-}
-export declare const handle: FailureHandler<ReturningAfter24hInfo>;

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

@@ -1,30 +0,0 @@
-/**
- * src/channels/telegram-mirror/failure/types.ts — v0.25.0 M12 shared types.
- *
- * Each failure mode lives in its own file per ADR-008 ("per-mode handlers
- * make each response shape testable and grep-able"). This file holds the
- * shared types so the 8 handler modules stay tight (each ~30-50 lines).
- */
-import type { TelegramAction } from '../commands.js';
-export interface FailureContext {
-    chatId: string | number;
-}
-export type Severity = 'info' | 'warn' | 'error';
-/**
- * Shape every failure handler exports. Handlers are pure functions:
- * inputs are the chat context + an optional info payload; output is the
- * array of TelegramAction the dispatch layer applies.
- */
-export type FailureHandler<I = unknown> = (ctx: FailureContext, info?: I) => TelegramAction[];
-/**
- * Registry-side metadata per failure module. Asserted by M13's chaos
- * test against the file name + handler shape.
- */
-export interface FailureModuleMeta {
-    /** Mode id, matches the file name without the .ts extension. */
-    mode: string;
-    /** Glyph that prefixes every emitted message for this mode. */
-    glyph: string;
-    /** Severity classification used by the chaos test + observability. */
-    severity: Severity;
-}

package/dist/src/channels/telegram-mirror/inbound-handler.d.ts

@@ -1,73 +0,0 @@
-/**
- * src/channels/telegram-mirror/inbound-handler.ts — v0.25.1 wire-up.
- *
- * The piece that was missing from v0.25.0: subscribes to OpenClaw's
- * `before_dispatch` event, identifies mirror slash commands, routes
- * through `dispatchCommand` (from commands.ts), and forwards the
- * resulting TelegramAction list out via `telegram-bot-api`'s sendTg.
- *
- * Returns `{ handled: true }` on dispatch so OpenClaw's default model
- * route (or any built-in command handler) doesn't ALSO respond — the
- * legacy event-reducer's `/quota` / `/sessions` handlers used the same
- * claim shape.
- *
- * Out-of-scope for v0.25.1 (deferred to v0.25.2+):
- *   • Tool/text/turn stream-event subscription → mirror-card render.
- *   • callback_query handling for inline-keyboard taps.
- *   • Burst-accumulator + compose-buffer engine injection (the
- *     ComposeBuffer + BurstAccumulator capture user text but the
- *     concatenated payload from /send still needs to reach the engine
- *     as a synthetic user message — that's a separate dispatch path).
- *
- * Single shared CallbackMap + ComposeBuffer per process so callback
- * resolution and compose state survive across handler invocations.
- */
-import { type TelegramAction } from './commands.js';
-import { CallbackMap } from './callback-mapping.js';
-import { ComposeBuffer } from './compose-buffer.js';
-import { type InteractiveCtx, type InjectApi } from './askuser.js';
-interface InboundLogger {
-    info: (msg: string) => void;
-    warn: (msg: string) => void;
-}
-export interface InboundHandlerApi {
-    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
-    logger?: {
-        info: (msg: string) => void;
-        warn: (msg: string) => void;
-    };
-    /** v0.26.3 M5 — forwarded from the full OpenClaw plugin api (index.ts) so
-     *  AskUserQuestion inline-keyboard taps can be received + answered. Optional:
-     *  absent on OpenClaw builds that don't expose it. */
-    registerInteractiveHandler?: (registration: {
-        channel: string;
-        namespace: string;
-        handler: (ctx: InteractiveCtx) => unknown;
-    }) => unknown;
-    enqueueNextTurnInjection?: InjectApi['enqueueNextTurnInjection'];
-}
-/**
- * Internal handler state — exported only for tests so they can inspect
- * compose-buffer state + callback-map without going through Telegram.
- */
-export interface HandlerState {
-    callbackMap: CallbackMap;
-    composeBuffer: ComposeBuffer;
-}
-export declare function createHandlerState(): HandlerState;
-/**
- * Forward a single TelegramAction to the actual Telegram API. Returns
- * the API response (or {ok:false} on failure). Pure I/O — no state
- * mutation. Exported for unit testing (planning M-B/B2).
- *
- * planning M-B/B2 (D-3): the `sendDocument` branch is now wired to the
- * multipart `sendDocumentTg` helper (was a no-op warn). NOTE: the PRODUCER of
- * sendDocument actions — ExitPlanMode detection → buildPlanAttachment — is
- * milestone M-B/B3, deferred pending probe P0-B. Until B3 lands this branch is
- * dormant forwarding infrastructure, not yet a user-reachable feature.
- */
-export declare function forwardAction(action: TelegramAction, threadId: number | undefined, logger: InboundLogger): Promise<void>;
-/** Test-only — reset module-level dispatch + card state. */
-export declare function _resetSubscriptionForTests(): void;
-export declare function registerInboundHandler(api: InboundHandlerApi, state?: HandlerState): HandlerState;
-export {};

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

@@ -1,32 +0,0 @@
-/**
- * src/channels/telegram-mirror/index.ts — v0.25.0 Telegram Terminal Mirror entry.
- *
- * Parallel implementation per ADR-002. The legacy 14-module live card at
- * src/channels/telegram/ is read-only observability; this mirror replaces it
- * with a Telegram-native surface (sessions/plan/cost/compose/etc.) so A1 can
- * drive cc-openclaw from phone without opening the laptop.
- *
- * M0 milestone (this file): empty register() stub gated by
- * CC_OPENCLAW_TERMINAL_MIRROR=1. Subsequent milestones (M1..M16) wire each
- * subsystem in dependency order. The flag picks which channel barrel loads
- * at boot — legacy and mirror are mutually exclusive (no double-listener
- * collisions). Roadmap + ADRs live at
- * /home/a1xai/dev/cc-openclaw/PRPs/v0.25.0-telegram-terminal-mirror.md.
- *
- * ADRs touched at M0: ADR-002 (parallel impl, not in-place).
- * Risks monitored: R-7 (parallel maintenance burden — re-evaluate at soak start).
- */
-export interface PluginApi {
-    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
-    logger?: Console;
-    registerInteractiveHandler?: (registration: unknown) => unknown;
-    enqueueNextTurnInjection?: (injection: unknown) => unknown;
-}
-/**
- * Mirror channel register — idempotent via defaultRegisterGuard.
- *
- * M0: empty stub. No api.on() wiring yet; subsequent milestones add handlers.
- * The stub still completes successfully so M0's exit criterion ("Plugin boot
- * succeeds in both flag states") holds end-to-end.
- */
-export declare function register(api: PluginApi): void;

package/dist/src/channels/telegram-mirror/plan-attachment.d.ts

@@ -1,120 +0,0 @@
-/**
- * src/channels/telegram-mirror/plan-attachment.ts — v0.25.0 M9.
- *
- * When Claude emits ExitPlanMode (the plan-mode tool call), the mirror
- * uploads the plan body as a .md document attachment with two inline
- * buttons (Approve / Reject). Decision: ADR-006 — sendDocument over
- * editMessageMedia. Rationale: sendDocument is simpler, has the larger
- * size limit, and matches A1's on-disk plan-file convention.
- *
- * Approve → callback payload `{ action: 'plan-approve', planId }` resolves
- * to model input "approved" which the engine bridge feeds to the running
- * session.
- *
- * Reject → two-phase. The first tap stashes a pending-reject for the chat;
- * the next non-slash inbound message becomes the rejection feedback payload
- * "<plan rejected>\n<feedback text>". A tap-then-tap-Reject again clears
- * the pending state silently.
- *
- * Risk references: R-3 (callback_data 64-byte cap) — payloads here route
- * through CallbackMap exactly like M3's keyboard.
- */
-import type { CallbackMap } from './callback-mapping.js';
-import type { TelegramAction } from './commands.js';
-/**
- * Shape of the ExitPlanMode tool_use event we care about. Mirrors the
- * subset of the upstream stream-event shape — keep narrow so future
- * upstream changes don't ripple here unnecessarily.
- */
-export interface ExitPlanModeEvent {
-    /** Tool name; always "ExitPlanMode" for this handler. */
-    toolName: string;
-    /** Free-form plan body (Markdown). */
-    plan: string;
-    /** Optional project slug — used in the .md filename. */
-    slug?: string;
-    /** Optional caption to surface above the document on Telegram (kept short). */
-    caption?: string;
-}
-/**
- * Compose the slug-prefixed plan filename. Sanitises non-filename chars
- * so the Telegram upload always succeeds.
- */
-export declare function planFilename(slug: string | undefined): string;
-/**
- * Build a sendDocument action carrying the plan + the Approve/Reject
- * inline keyboard. The callback ids are minted into the supplied
- * CallbackMap; payloads include a fresh planId so multiple in-flight
- * plans on the same chat don't collide.
- */
-export declare function buildPlanAttachment(opts: {
-    chatId: string | number;
-    event: ExitPlanModeEvent;
-    callbackMap: CallbackMap;
-    /** Optional planId override for deterministic tests. */
-    planId?: string;
-}): {
-    action: Extract<TelegramAction, {
-        type: 'sendDocument';
-    }>;
-    planId: string;
-};
-interface RejectPending {
-    chatId: string;
-    planId: string;
-    pendingSince: number;
-}
-export interface RejectFeedbackTrackerOptions {
-    /** TTL after which a pending-reject silently expires (default 10 min). */
-    ttlMs?: number;
-    /** Clock for tests. */
-    now?: () => number;
-}
-/**
- * Tracks the (chatId → pending-reject) state for two-phase rejection.
- * The dispatch layer pokes startPending on a Reject tap and consumeFeedback
- * on the next non-slash inbound. Pending-state TTL prevents a half-open
- * rejection from corrupting later turns.
- */
-export declare class RejectFeedbackTracker {
-    private readonly pending;
-    private readonly ttlMs;
-    private readonly now;
-    constructor(opts?: RejectFeedbackTrackerOptions);
-    /**
-     * Mark a chat as having tapped Reject and waiting for feedback. If a
-     * prior pending exists, it is replaced (the user re-tapped on a newer plan).
-     */
-    startPending(chatId: string, planId: string): void;
-    /**
-     * Returns true when the chat has a non-stale pending-reject.
-     */
-    isPending(chatId: string): boolean;
-    /**
-     * Consume the next inbound text as the rejection feedback. Returns a
-     * formatted payload that the engine bridge feeds to openai-compat as a
-     * single user-message, or undefined when no pending state exists.
-     *
-     * Payload shape: "<plan rejected: planId>\n<feedback text>" — the
-     * "<plan rejected>" sentinel lets the model recognise this as
-     * rejection feedback (not a new turn).
-     */
-    consumeFeedback(chatId: string, feedback: string): string | undefined;
-    /**
-     * Drop the pending state without consuming feedback (e.g. user taps
-     * Reject twice, or types another slash command in the interim).
-     */
-    cancel(chatId: string): boolean;
-    /**
-     * Inspect pending without consuming. Filters expired entries.
-     */
-    peek(chatId: string): RejectPending | undefined;
-    clear(): void;
-}
-/**
- * Helper: format the approve payload as engine input. Kept as a function
- * (not a constant) so future variants — e.g. caching a planId reference —
- * have a single place to extend.
- */
-export declare function formatApprovePayload(planId: string): string;
-export {};

package/dist/src/channels/telegram-mirror/quota-reader.d.ts

@@ -1,42 +0,0 @@
-/**
- * src/channels/telegram-mirror/quota-reader.ts — v0.25.0 M4 stub.
- *
- * Minimal QuotaSnapshot interface and a zero-valued reader so /cost in M4
- * has something to render. M11 replaces the stub with a wire-up to the
- * production status-tee-reader.ts that the existing /cost handler in the
- * legacy live card already consumes.
- *
- * Decision-link: M11 owns threshold-notification + detail-view wiring;
- * keeping the surface here in M4 isolates the command-handler layer from
- * the status-tee read path (so M11 can swap implementations without
- * touching commands.ts).
- */
-interface QuotaPerDay {
-    /** YYYY-MM-DD */
-    date: string;
-    /** 0..100 — percentage of the daily Max 20x window consumed. */
-    percent: number;
-}
-export interface QuotaSnapshot {
-    /** Current Max 20x consumption as 0..100 percent. */
-    maxPercent: number;
-    /** Weekly burn in USD (extra_usage overage tracked separately by status-tee). */
-    weeklyBurn: number;
-    /** Sessions ranked by token consumption (top-5). */
-    topSessions: Array<{
-        slug: string;
-        tokens: number;
-    }>;
-    /** Per-day rollup, most-recent-first (capped at 7). */
-    perDayRollup: QuotaPerDay[];
-}
-export interface QuotaReader {
-    read(): QuotaSnapshot;
-}
-/**
- * Stub reader for M4 — returns a known-zero snapshot. M11 replaces this
- * with a wire to status-tee-reader.ts. Tests can pass their own reader
- * directly to the cost command for fixture-based assertions.
- */
-export declare const stubQuotaReader: QuotaReader;
-export {};

package/dist/src/channels/telegram-mirror/sessions-keyboard.d.ts

@@ -1,84 +0,0 @@
-/**
- * src/channels/telegram-mirror/sessions-keyboard.ts — v0.25.0 M3.
- *
- * Builds the inline keyboard for /sessions. Pure function — takes a row
- * list + page index + a CallbackMap, returns Telegram's inline_keyboard
- * shape. Caller is responsible for sending/editing the surrounding
- * Telegram message via the dispatch layer.
- *
- * Decision refs:
- *   • ADR-003 — slug ↔ sessionName comes from session-registry; the row
- *     list here is a denormalised SessionRow because the keyboard also
- *     needs live state + lastUsedAt, which the registry doesn't track
- *     (state lives in session-manager, time-since lives in the registry's
- *     lastUsedAt). The handler in M4 stitches them together.
- *   • ADR-004 — every callback_data slot is a CallbackMap id, not a raw
- *     JSON payload. Keeps every button under the 64-byte cap by design.
- *   • ADR-005 — page size is 8; 9th row is "▶ More" when more pages exist.
- */
-import type { CallbackMap } from './callback-mapping.js';
-export declare const SESSIONS_PAGE_SIZE = 8;
-export type SessionState = 'running' | 'stopped' | 'idle';
-export interface SessionRow {
-    slug: string;
-    sessionName: string;
-    state: SessionState;
-    /** ISO timestamp — the registry's lastUsedAt. */
-    lastUsedAt: string;
-}
-export interface InlineButton {
-    text: string;
-    callback_data: string;
-}
-export interface SessionsKeyboardResult {
-    inline_keyboard: InlineButton[][];
-    /** Zero-indexed page rendered. */
-    page: number;
-    /** Total page count (≥ 1 even when rows is empty). */
-    pageCount: number;
-    /** True when there is at least one page after the rendered one. */
-    hasMore: boolean;
-}
-/**
- * Compact relative-time string for a row's lastUsedAt.
- *   < 60s   →  "<1m"
- *   < 1h    →  "Nm"
- *   < 1d    →  "Nh"
- *   else    →  "Nd"
- * Designed to fit in 4 chars so the row stays narrow on phone Telegram.
- */
-export declare function formatLastActivity(lastUsedAt: string, now?: number): string;
-/**
- * Format a row label.  "cc-openclaw · 🟢 · 2m"
- */
-export declare function formatSessionRowLabel(row: SessionRow, now?: number): string;
-export interface SessionsKeyboardOpts {
-    rows: SessionRow[];
-    /** Zero-indexed page; clamped into [0, pageCount-1]. */
-    page?: number;
-    callbackMap: CallbackMap;
-    /** Override clock for tests. */
-    now?: number;
-}
-/**
- * Build the full /sessions inline keyboard. Layout:
- *
- *   Row 1..N    session rows (one button each)        (N ≤ 8)
- *   Row N+1     "▶ More" — only when hasMore===true
- *   Row last    "➕ New" "🗑 Stop" "✖ Close"          (always)
- *
- * Every button's callback_data is a CallbackMap id pointing at a payload:
- *   session row →  { action: 'switch', slug }
- *   ▶ More       →  { action: 'page', page: N+1 }
- *   ➕ New       →  { action: 'new' }
- *   🗑 Stop      →  { action: 'stop' }
- *   ✖ Close      →  { action: 'close' }
- */
-export declare function buildSessionsKeyboard(opts: SessionsKeyboardOpts): SessionsKeyboardResult;
-/**
- * Helper: every button's callback_data must fit in 64 UTF-8 bytes per
- * Telegram's API. We enforce this at build time as a defense-in-depth
- * check — even an 8-char id is well under, but a future refactor that
- * stuffs raw JSON would silently break Telegram without this assertion.
- */
-export declare function assertCallbackDataBudget(keyboard: SessionsKeyboardResult): void;