@a1hvdy/cc-openclaw 0.30.0 → 0.31.0

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;

package/dist/src/channels/telegram-mirror/soak-log.d.ts

@@ -1,99 +0,0 @@
-/**
- * src/channels/telegram-mirror/soak-log.ts — v0.25.0 M14.
- *
- * Daily JSONL incident + activity log for the 2-week soak (M14 → M15
- * cutover gate). Writes append-only rows to
- *   workspace/memory/mirror-soak-<YYYY-MM-DD>.jsonl
- * per PRP §5 M14. The file rolls at UTC midnight (date-stamped path).
- *
- * Three row types per spec:
- *   • laptop-check       — A1 self-reports opened-laptop-today via /soak-check.
- *   • failure-incident   — fires once per M12 handler invocation in soak.
- *   • slash-invocation   — one row per slash command dispatch.
- *
- * Idempotency: a single laptop-check per UTC day. recordLaptopCheck()
- * returns false on the second call within a day so the /soak-check
- * handler can surface "already recorded today" UX rather than logging
- * duplicates.
- *
- * Decision-link: this file is the only filesystem-touching mirror module
- * outside session-registry (M1). Both share the atomic-write-via-rename
- * idiom; soak-log appends so it doesn't need the tmpfile dance, but the
- * path resolution is the same shape.
- */
-export type SoakRow = SoakLaptopCheckRow | SoakFailureRow | SoakSlashRow;
-interface SoakLaptopCheckRow {
-    ts: string;
-    type: 'laptop-check';
-    openedLaptop: boolean;
-}
-interface SoakFailureRow {
-    ts: string;
-    type: 'failure-incident';
-    mode: string;
-    chatId: string | number;
-    info?: unknown;
-}
-interface SoakSlashRow {
-    ts: string;
-    type: 'slash-invocation';
-    cmd: string;
-    chatId: string | number;
-}
-export interface SoakLoggerOptions {
-    /** Override base dir for tests (defaults to ~/.openclaw/workspace/memory). */
-    dir?: string;
-    /** Override clock for tests. */
-    now?: () => Date;
-}
-export declare class SoakLogger {
-    private readonly dir;
-    private readonly now;
-    constructor(opts?: SoakLoggerOptions);
-    /**
-     * Absolute path of today's JSONL file. Honors the configured clock.
-     */
-    pathForToday(): string;
-    /**
-     * Append a row to today's file. Creates the parent directory if missing.
-     * Each row is `JSON.stringify(row) + '\n'`.
-     */
-    append(row: SoakRow): void;
-    /**
-     * Read all rows for today (parsing each line). Returns [] when the
-     * file is missing OR when every line is malformed.
-     */
-    readToday(): SoakRow[];
-    /**
-     * Returns true iff a laptop-check row has already been written today.
-     * Used by /soak-check's once-per-day gate.
-     */
-    hasLaptopCheckToday(): boolean;
-    /**
-     * Idempotent laptop-check writer. Returns true when the row was
-     * persisted, false when a check was already recorded today.
-     */
-    recordLaptopCheck(openedLaptop: boolean): boolean;
-    /**
-     * Failure-incident logger — called by the dispatcher when a M12
-     * handler fires. The info payload is opaque JSON; the schema is
-     * per-mode and lives in the handler's documentation.
-     */
-    recordFailure(mode: string, chatId: string | number, info?: unknown): void;
-    /**
-     * Slash-invocation logger — called once per dispatchCommand call by
-     * the dispatcher (M5+). Cheap to record and lets the soak surface
-     * which commands A1 actually uses on phone.
-     */
-    recordSlash(cmd: string, chatId: string | number): void;
-    /**
-     * Count rows by type for the day — used by M15's "5/7 no-laptop days"
-     * gate without having to ship a separate aggregator.
-     */
-    countByType(): {
-        'laptop-check': number;
-        'failure-incident': number;
-        'slash-invocation': number;
-    };
-}
-export {};

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

@@ -1,113 +0,0 @@
-/**
- * src/channels/telegram-mirror/state-machine.ts — v0.25.0 M2.
- *
- * Per-chat turn-lifecycle state machine for the Telegram Terminal Mirror.
- * Consumes Claude stream events (tool_use / tool_result / text / turn_done)
- * and produces a Turn object the card-renderer (sibling module) can format
- * into Telegram message bodies.
- *
- * Naming note: this is NOT a 1:1 port of the legacy state-machine.ts —
- * legacy is a message_sending cross-path-dedup hook. Per ADR-001 (mimic
- * the terminal flow) the mirror's state-machine models what a user sees
- * during a turn (running tools → completion), which is closer to a UI
- * controller than legacy's API-dispatch hook. The name is reused for
- * cross-reference clarity; the shape diverges intentionally.
- *
- * Pure module — no I/O, no Telegram-API calls. Wiring into register() and
- * the actual gateway event bus lands in M3/M4 once /sessions provides a
- * user-facing entry point. M2's scope: the abstraction + tests.
- */
-/**
- * Stream event shape (mirrors the subset of legacy card-renderer.ts
- * StreamEvent that the mirror actually consumes). Re-exported here so
- * dependents don't need to import from the legacy directory.
- */
-export interface StreamEvent {
-    type: string;
-    id?: string;
-    tool_use_id?: string;
-    tool?: {
-        name?: string;
-        input?: Record<string, unknown>;
-    };
-    tool_name?: string;
-    input?: Record<string, unknown>;
-    content?: unknown;
-    output?: unknown;
-    is_error?: boolean;
-    error?: unknown;
-    result?: string;
-}
-type TurnState = 'working' | 'done' | 'failed';
-export interface ToolCallRecord {
-    /** Tool name (e.g. "Bash", "Read", "Edit"). */
-    name: string;
-    /** Tool input arguments (snapshot at tool_use time). */
-    input: Record<string, unknown>;
-    /** Telegram-readable tool-use id, used to match tool_result events. */
-    toolUseId: string;
-    /** Set when the matching tool_result event arrives. */
-    result?: unknown;
-    /** True if the tool_result event flagged is_error/error. */
-    isError?: boolean;
-}
-export interface Turn {
-    /** Telegram chat id this turn is rendering into. */
-    chatId: string;
-    /** Lifecycle state. */
-    state: TurnState;
-    /** Monotonic timestamp (Date.now()) when the turn started. */
-    startedAt: number;
-    /** Set when the turn transitions to 'done' or 'failed'. */
-    endedAt?: number;
-    /** Set when the turn transitions to 'failed' (M4) — a short failure reason
-     *  surfaced on the card so a turn never dies as an eternal "…". */
-    failReason?: string;
-    /** Tool calls observed during the turn, in arrival order. */
-    toolCalls: ToolCallRecord[];
-    /** Accumulated assistant text (concatenation of text events). */
-    assistantText: string;
-    /** Accumulated extended-thinking text (M6). Rendered above assistant text. */
-    thinkingText: string;
-}
-export declare class TurnStateMachine {
-    private readonly turns;
-    /**
-     * Start (or restart) a turn for the given chat. If a turn already exists,
-     * its 'done' state is preserved as the prior turn until a new start
-     * overwrites it — the mirror does not keep history at this layer.
-     */
-    start(chatId: string, now?: number): Turn;
-    /**
-     * Apply a stream event. Returns the updated turn, or undefined if no
-     * turn is active for the chat. The state machine accepts:
-     *   - tool_use     → push a ToolCallRecord
-     *   - tool_result  → resolve the matching ToolCallRecord
-     *   - text         → append to assistantText
-     * Other event types are ignored at this layer; downstream milestones add
-     * thinking/insight handling (M6) and plan-mode handling (M9).
-     */
-    applyEvent(chatId: string, event: StreamEvent): Turn | undefined;
-    /**
-     * End the active turn for chatId. Transitions state to 'done' and stamps
-     * endedAt. Returns the finalized turn, or undefined if no turn was active.
-     */
-    end(chatId: string, now?: number): Turn | undefined;
-    /**
-     * Fail the active turn for chatId (M4). Transitions state to 'failed', stamps
-     * endedAt, and records a short reason so renderTurn can show "❌ <reason>"
-     * instead of leaving the card frozen at "…". Returns the failed turn, or
-     * undefined if no turn was active.
-     */
-    fail(chatId: string, reason: string, now?: number): Turn | undefined;
-    /**
-     * Returns the active or most-recently-ended turn for chatId.
-     */
-    getTurn(chatId: string): Turn | undefined;
-    /**
-     * Drop the cached turn. Test-only convenience; production code starts a
-     * new turn instead.
-     */
-    clear(chatId: string): void;
-}
-export {};

package/dist/src/channels/telegram-mirror/status-line.d.ts

@@ -1,51 +0,0 @@
-/**
- * src/channels/telegram-mirror/status-line.ts — v0.26.2 M1.
- *
- * Builds the Claude-Code-CLI-style status line that sits at the top of the
- * Telegram live-mirror card, e.g.:
- *
- *   [Opus 4.7] · CC 2.1.145 · ⏱ 2h13m · 🔧 3 · bypass
- *
- * STRICT no-fake-data rule (per the v0.26.2 brief): every segment is rendered
- * ONLY when its value is genuinely available. Missing model / version / etc.
- * are simply omitted — never stubbed. Telegram has no ANSI color, so the CLI
- * look is approximated with `·` separators, glyphs, and (in later milestones)
- * unicode meter bars — plain text that survives the MarkdownV2→plain fallback.
- */
-import type { Turn } from './state-machine.js';
-import type { CardMeta } from './card-state.js';
-export declare function getCcVersion(): string | null;
-/** Test-only — reset the cached version. */
-export declare function _resetCcVersionForTests(): void;
-export declare function shortModel(model: string | undefined): string | undefined;
-/** Compact elapsed formatter: 2h13m / 13m / 42s. */
-export declare function fmtElapsed(ms: number): string;
-/**
- * Render the status line for a turn. Returns `undefined` when NOTHING is
- * available to show (so callers omit the line entirely). Segments, in order:
- *   [model] · CC <ver> · ⏱ <elapsed> · 🔧 <toolCount> · bypass
- * Every segment is conditional on real data.
- */
-export declare function renderStatusLine(turn: Turn, meta: CardMeta | undefined, now?: number): string | undefined;
-/** Unicode meter, e.g. meterBar(71) → "▓▓▓▓▓▓░░ 71%" (8 cells). */
-export declare function meterBar(pct: number, cells?: number): string;
-/** Quota reset formatter: within 24h → local clock (e.g. "4:20p"); else "in Nd". */
-export declare function fmtReset(epochSec: number, now?: number): string;
-/**
- * Second status row — the meter bars: context-window % and plan-usage/quota %
- * + reset. Each segment renders only when its value is genuinely present
- * (no-fake-data). Returns undefined when nothing is available.
- *   ctx ▓▓▓▓▓▓░░ 71% · use ▓▓▓░ 34% · resets 4:20p
- */
-export declare function renderMeters(meta: CardMeta | undefined, now?: number): string | undefined;
-/**
- * Render the agent's todo list (M4) as a compact checklist with a done/total
- * header, e.g.:
- *   todos 1/3
- *   ☑ wire bridge
- *   ▶ render status line
- *   ☐ ship release
- * Returns undefined when there are no todos (no-fake-data). Capped at TODO_MAX
- * rows with a "+N more" overflow line so the card stays readable.
- */
-export declare function renderTodos(meta: CardMeta | undefined): string | undefined;