@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

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

@@ -1,107 +0,0 @@
-/**
- * src/channels/telegram-mirror/askuser.ts — v0.26.3 M5.
- *
- * Renders Claude Code's AskUserQuestion tool as native Telegram inline
- * keyboards, "next-turn model" (Path A, chosen by A1 2026-05-20):
- *
- *   agent calls AskUserQuestion  → turn ends
- *   → we send a keyboard message (single-select: one button per option +
- *      "✍️ Write something else"; multi-select: checkbox toggles + Submit)
- *   → user taps  → api.registerInteractiveHandler fires
- *   → we answer the callback, edit the message to show the choice, and
- *      api.enqueueNextTurnInjection() queues the answer as context for the
- *      agent's NEXT turn (it is acted on when the next message runs — the
- *      documented primitive injects context, it does not start a turn).
- *
- * Feasibility proven 2026-05-20: the headless subprocess DOES emit an
- * AskUserQuestion tool_use (pushToolUse name=AskUserQuestion). The tool emits
- * twice (dual content_block_start + assistant-block), so capture dedups by
- * tool_use id.
- *
- * Telegram has no ANSI color — checkboxes use ☐/☑ glyphs.
- */
-/** Namespace prefix for callback_data so api.registerInteractiveHandler routes
- *  taps here. Matched at the first ':' by the gateway (must be [A-Za-z0-9._-]+). */
-export declare const ASKUSER_NS = "ccmirror";
-interface QOption {
-    label: string;
-    description?: string;
-}
-interface ParsedQuestion {
-    header: string;
-    question: string;
-    multiSelect: boolean;
-    options: QOption[];
-}
-/**
- * v0.28.0 — build a single inline button that, when tapped, resumes a Claude
- * Code session. Reuses the proven askuser callback path: the payload is stashed
- * in the shared (globalThis-anchored) CallbackMap and the callback_data is
- * `ccmirror:<id>`, so taps route through the same before_dispatch interceptor.
- */
-export declare function buildResumeButton(uuid: string, label: string): {
-    text: string;
-    callback_data: string;
-};
-/** Minimal subset of the registerInteractiveHandler ctx we use. */
-export interface InteractiveCtx {
-    callback: {
-        id?: string;
-        data?: string;
-        namespace?: string;
-        payload?: string;
-    };
-    chatId?: string | number;
-    conversationId?: string;
-    sessionKey?: string;
-    threadId?: number;
-    respond?: {
-        editMessage?: (text: string) => Promise<unknown>;
-        answer?: (text?: string) => Promise<unknown>;
-    };
-}
-/** Minimal subset of the plugin api we use (next-turn injection). */
-export interface InjectApi {
-    enqueueNextTurnInjection?: (injection: {
-        sessionKey: string;
-        text: string;
-        placement?: 'prepend_context' | 'append_context';
-        idempotencyKey?: string;
-    }) => unknown;
-}
-/** Record the real agent session key for a chat (called from inbound before_dispatch). */
-export declare function rememberSessionKey(chatId: string, sessionKey: string | undefined): void;
-/** Parse the FIRST question from an AskUserQuestion tool input. Defensive —
- *  returns undefined if the shape isn't usable (no fabrication). */
-export declare function parseFirstQuestion(input: Record<string, unknown> | undefined): ParsedQuestion | undefined;
-/**
- * Capture an AskUserQuestion tool_use and render the keyboard. Called from
- * turn-bridge when name === 'AskUserQuestion'. Dedups the dual-emission by
- * tool_use id. Best-effort: a send failure must not break the turn.
- */
-export declare function captureAskUserQuestion(chatId: string, threadId: number | undefined, input: Record<string, unknown> | undefined, toolUseId: string | undefined): Promise<void>;
-/**
- * Handle an inline-button tap routed from api.registerInteractiveHandler.
- * Resolves the callback payload, updates state, and on a terminal choice
- * (single-select option, multi-select Submit) injects the answer for the next
- * turn. "Write something else" just prompts the user to type — their typed
- * message becomes the next turn naturally, so no injection is needed.
- */
-export declare function handleTap(ctx: InteractiveCtx, api: InjectApi): Promise<void>;
-/** True if an inbound message text is actually an AskUserQuestion button tap.
- *  The gateway delivers taps on plugin-sent keyboards as before_dispatch
- *  messages with text = the callback_data (`ccmirror:<id>`), NOT as routed
- *  interactive-handler callbacks — so we intercept them in before_dispatch. */
-export declare function isAskUserCallback(text: string): boolean;
-/**
- * Handle a tap that arrived as a before_dispatch message (text=`ccmirror:<id>`).
- * Builds a synthetic ctx (conversationId = chatId resolves the remembered
- * session key) and runs the normal tap logic. Caller MUST claim the event so
- * the literal callback_data never reaches the agent.
- */
-export declare function handleTapData(text: string, chatId: string, api: InjectApi): Promise<void>;
-/** Test-only — reset module state. */
-export declare function _resetAskUserForTests(): void;
-/** Test-only — peek pending question count. */
-export declare function _pendingCount(): number;
-export {};

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