@a1hvdy/cc-openclaw 0.30.0 → 0.31.0

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

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