@a1hvdy/cc-openclaw 0.23.0 → 0.25.0

package/dist/src/channels/telegram-mirror/card-renderer.js

@@ -0,0 +1,131 @@
+/**
+ * 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.
+ */
+/**
+ * Glyph picked per tool-call status. Mirrors terminal "running / done /
+ * errored" iconography that A1 already reads in the live Claude Code TUI.
+ */
+function toolGlyph(tc) {
+    if (tc.isError)
+        return '✗';
+    if (tc.result !== undefined)
+        return '✓';
+    return '…';
+}
+/**
+ * Render the input argument summary for a tool call. Kept tight — full
+ * input is in the result; the mirror line is meant to read at a glance.
+ */
+function toolInputSummary(tc) {
+    const input = tc.input;
+    if (!input || typeof input !== 'object')
+        return '';
+    // Prefer common single-field shapes used by Bash/Read/Edit/Write.
+    const single = typeof input.command === 'string'
+        ? input.command
+        : typeof input.file_path === 'string'
+            ? input.file_path
+            : typeof input.path === 'string'
+                ? input.path
+                : typeof input.url === 'string'
+                    ? input.url
+                    : '';
+    if (single) {
+        return single.length > 60 ? single.slice(0, 57) + '...' : single;
+    }
+    return '';
+}
+/**
+ * Format one tool-call line for inclusion in the rendered card body.
+ *   "✓ Bash · ls -la"
+ *   "… Read · src/index.ts"
+ *   "✗ Edit · …error glyph at left"
+ */
+export function renderToolLine(tc) {
+    const glyph = toolGlyph(tc);
+    const summary = toolInputSummary(tc);
+    return summary ? `${glyph} ${tc.name} · ${summary}` : `${glyph} ${tc.name}`;
+}
+/**
+ * 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 function renderThinkingBlock(thinkingText) {
+    const trimmed = thinkingText.trim();
+    if (trimmed.length === 0)
+        return '';
+    const lines = trimmed.split('\n');
+    return ['💭 Thinking', ...lines.map((l) => `> ${l}`)].join('\n');
+}
+/**
+ * Render the full turn into a Telegram-safe message body. The mirror keeps
+ * a single message per turn that gets edited in place — this function is
+ * idempotent for a given turn snapshot and produces the next body string.
+ *
+ * Body shape (lines separated by \n):
+ *
+ *   ▶ Working           ← or "✓ Done" when state==='done'
+ *   ✓ Bash · ls -la     ← one line per tool call, in arrival order
+ *   … Read · src/x.ts
+ *   <empty line>
+ *   💭 Thinking         ← M6, only when thinkingText non-empty
+ *   > reasoning line 1
+ *   > reasoning line 2
+ *   <empty line>
+ *   <assistant text>    ← present only when non-empty;
+ *                          ★ Insight ─ blocks preserved INLINE
+ *                          at their emission position (M6).
+ *
+ * Lines with no content (e.g. empty tool list, empty assistant text) are
+ * omitted entirely so the rendered body never has trailing whitespace.
+ */
+export function renderTurn(turn) {
+    const header = turn.state === 'done' ? '✓ Done' : '▶ Working';
+    const lines = [header];
+    if (turn.toolCalls.length > 0) {
+        for (const tc of turn.toolCalls) {
+            lines.push(renderToolLine(tc));
+        }
+    }
+    // Defensive default — Turn.thinkingText is required by the interface, but
+    // some test helpers and pre-M6 fixtures construct Turn-shaped objects
+    // without setting it. Treat absent / undefined as empty.
+    const thinking = renderThinkingBlock(turn.thinkingText ?? '');
+    if (thinking.length > 0) {
+        lines.push('');
+        lines.push(thinking);
+    }
+    const text = turn.assistantText.trim();
+    if (text.length > 0) {
+        lines.push('');
+        lines.push(text);
+    }
+    return lines.join('\n');
+}
+/**
+ * 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 function planRenderAction(turn, knownMessageId) {
+    const text = renderTurn(turn);
+    if (knownMessageId === undefined) {
+        return { type: 'send', chatId: turn.chatId, text };
+    }
+    return { type: 'edit', chatId: turn.chatId, text, messageId: knownMessageId };
+}
+//# sourceMappingURL=card-renderer.js.map

package/dist/src/channels/telegram-mirror/card-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"card-renderer.js","sourceRoot":"","sources":["../../../../src/channels/telegram-mirror/card-renderer.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,142 @@
+/**
+ * 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;
+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;
+/**
+ * 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;
+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/commands.js

@@ -0,0 +1,389 @@
+/**
+ * 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 { register, unregister, list, getBySlug, } from '../../lib/session-registry.js';
+import { buildSessionsKeyboard, formatLastActivity, } from './sessions-keyboard.js';
+import { stubQuotaReader } from './quota-reader.js';
+export function parseSlash(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/'))
+        return undefined;
+    const tokens = trimmed.slice(1).split(/\s+/).filter((t) => t.length > 0);
+    if (tokens.length === 0)
+        return undefined;
+    const head = tokens[0];
+    const cmd = head.includes('@') ? head.split('@')[0] : head;
+    return { cmd: cmd.toLowerCase(), args: tokens.slice(1) };
+}
+// ── /sessions ────────────────────────────────────────────────────────────
+function enrichRows(entries, stateLookup) {
+    return entries.map((e) => ({
+        slug: e.slug,
+        sessionName: e.sessionName,
+        state: stateLookup(e.slug),
+        lastUsedAt: e.lastUsedAt,
+    }));
+}
+export function handleSessions(ctx) {
+    const entries = list();
+    const stateLookup = ctx.stateLookup ?? (() => 'idle');
+    const rows = enrichRows(entries, stateLookup);
+    const kb = buildSessionsKeyboard({
+        rows,
+        callbackMap: ctx.callbackMap,
+        now: ctx.now,
+    });
+    const header = entries.length === 0
+        ? 'No sessions registered yet. Tap ➕ New to create one.'
+        : `Sessions (${entries.length})${kb.pageCount > 1 ? ` · page ${kb.page + 1}/${kb.pageCount}` : ''}`;
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: header,
+                reply_markup: { inline_keyboard: kb.inline_keyboard },
+            },
+        ],
+    };
+}
+// ── /new <slug> ──────────────────────────────────────────────────────────
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-_]{0,39}$/i;
+export function handleNew(ctx) {
+    const slug = ctx.args[0];
+    if (!slug) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: 'Usage: /new <slug>\nExample: /new cc-openclaw',
+                },
+            ],
+        };
+    }
+    if (!SLUG_PATTERN.test(slug)) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: `Invalid slug "${slug}". Use [a-z0-9-_], max 40 chars, starting with [a-z0-9].`,
+                },
+            ],
+        };
+    }
+    const existing = getBySlug(slug);
+    // Session-name comes from the engine; M4 stores a placeholder that M5+ overwrites.
+    const sessionName = existing?.sessionName ?? `pending-${slug}-${Date.now()}`;
+    register(slug, sessionName);
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: existing
+                    ? `Session "${slug}" already registered — fronted.`
+                    : `Session "${slug}" registered. Engine wire-up lands in M5.`,
+            },
+        ],
+    };
+}
+// ── /stop ────────────────────────────────────────────────────────────────
+export function handleStop(ctx) {
+    const slug = ctx.args[0];
+    if (!slug) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: 'Usage: /stop <slug>',
+                },
+            ],
+        };
+    }
+    const removed = unregister(slug);
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: removed
+                    ? `Session "${slug}" stopped.`
+                    : `No registered session named "${slug}".`,
+            },
+        ],
+    };
+}
+// ── /status ──────────────────────────────────────────────────────────────
+export function handleStatus(ctx) {
+    const entries = list();
+    const stateLookup = ctx.stateLookup ?? (() => 'idle');
+    const now = ctx.now ?? Date.now();
+    if (entries.length === 0) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: 'No sessions registered.',
+                },
+            ],
+        };
+    }
+    const lines = [`Active sessions: ${entries.length}`];
+    for (const e of entries) {
+        lines.push(`• ${e.slug} (${stateLookup(e.slug)}, ${formatLastActivity(e.lastUsedAt, now)})`);
+    }
+    return {
+        actions: [{ type: 'sendMessage', chat_id: ctx.chatId, text: lines.join('\n') }],
+    };
+}
+// ── /compact ─────────────────────────────────────────────────────────────
+export function handleCompact(ctx) {
+    // M4: surface the intent. Actual context-compaction wiring runs through
+    // the cc-handler module (existing /cc compact path) — bridging the
+    // mirror to that handler lands in M5 alongside the rest of the engine
+    // integration. Without the bridge, the user sees a clear "queued" state.
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: '⏳ Compact queued — engine wire-up lands in M5.',
+            },
+        ],
+    };
+}
+// ── /cost ────────────────────────────────────────────────────────────────
+function formatQuotaSummary(snap) {
+    const pct = snap.maxPercent.toFixed(1);
+    const burn = snap.weeklyBurn.toFixed(2);
+    return `Max 20x: ${pct}% used · Weekly burn: $${burn}`;
+}
+export function handleCost(ctx) {
+    const reader = ctx.quotaReader ?? stubQuotaReader;
+    const snap = reader.read();
+    const summaryText = formatQuotaSummary(snap);
+    // Inline detail button — payload tells the callback handler (M11+) which
+    // subview to expand: per-day rollup, top sessions, or weekly burn breakdown.
+    const detailCb = ctx.callbackMap.create({ action: 'cost-detail' });
+    const dailyCb = ctx.callbackMap.create({ action: 'cost-daily' });
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: summaryText,
+                reply_markup: {
+                    inline_keyboard: [
+                        [{ text: '📊 Detail', callback_data: detailCb }],
+                        [{ text: '📅 Per-day', callback_data: dailyCb }],
+                    ],
+                },
+            },
+        ],
+    };
+}
+// ── /rewind ──────────────────────────────────────────────────────────────
+export function handleRewind(ctx) {
+    // M4: queued — actual rewind walks the cc-handler resume path (deferred
+    // to M5 with the rest of engine bridging).
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: '⏪ Rewind queued — engine wire-up lands in M5.',
+            },
+        ],
+    };
+}
+// ── /compose ─────────────────────────────────────────────────────────────
+/**
+ * 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 function handleCompose(ctx) {
+    if (!ctx.composeBuffer) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: '⚠️ /compose unavailable — buffer not wired in this context.',
+                },
+            ],
+        };
+    }
+    ctx.composeBuffer.start(String(ctx.chatId));
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: '✍️ Compose mode opened. Send messages; finish with /send (or /cancel to abort).',
+            },
+        ],
+    };
+}
+/**
+ * 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 function handleSend(ctx) {
+    if (!ctx.composeBuffer) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: '⚠️ /send unavailable — buffer not wired in this context.',
+                },
+            ],
+        };
+    }
+    const payload = ctx.composeBuffer.commit(String(ctx.chatId));
+    if (payload === undefined) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: 'No compose session active. Start one with /compose.',
+                },
+            ],
+        };
+    }
+    // Confirmation surfaces a short preview (≤ 120 chars) so the user sees
+    // what was sent. The full payload travels via CommandResult.delivery
+    // for M5+ engine bridging.
+    const preview = payload.length > 120 ? payload.slice(0, 117) + '...' : payload;
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: `📤 Sent (${payload.length} chars): ${preview}`,
+            },
+        ],
+        delivery: { payload },
+    };
+}
+/**
+ * Cancel the active compose buffer without sending. Useful when the user
+ * starts composing then changes their mind.
+ */
+export function handleCancel(ctx) {
+    if (!ctx.composeBuffer) {
+        return {
+            actions: [
+                {
+                    type: 'sendMessage',
+                    chat_id: ctx.chatId,
+                    text: '⚠️ /cancel unavailable — buffer not wired in this context.',
+                },
+            ],
+        };
+    }
+    const had = ctx.composeBuffer.cancel(String(ctx.chatId));
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: had ? '🚫 Compose cancelled.' : 'No compose session was active.',
+            },
+        ],
+    };
+}
+// ── /soak-check (M14) ────────────────────────────────────────────────────
+/**
+ * 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 function handleSoakCheck(ctx) {
+    const yesCb = ctx.callbackMap.create({ action: 'soak-check', openedLaptop: true });
+    const noCb = ctx.callbackMap.create({ action: 'soak-check', openedLaptop: false });
+    return {
+        actions: [
+            {
+                type: 'sendMessage',
+                chat_id: ctx.chatId,
+                text: 'Opened the laptop today? (one tap per day for v0.25.0 soak)',
+                reply_markup: {
+                    inline_keyboard: [
+                        [
+                            { text: '✅ Yes', callback_data: yesCb },
+                            { text: '❌ No', callback_data: noCb },
+                        ],
+                    ],
+                },
+            },
+        ],
+    };
+}
+export const COMMAND_HANDLERS = {
+    sessions: handleSessions,
+    new: handleNew,
+    stop: handleStop,
+    status: handleStatus,
+    compact: handleCompact,
+    cost: handleCost,
+    rewind: handleRewind,
+    compose: handleCompose,
+    send: handleSend,
+    cancel: handleCancel,
+    'soak-check': handleSoakCheck,
+};
+/**
+ * Telegram bot commands list — declarative source for M5's setMyCommands sync.
+ */
+export const TOP_7_COMMANDS = [
+    { command: 'sessions', description: 'List + switch fronted Claude session' },
+    { command: 'new', description: 'Register a new session slug — /new <slug>' },
+    { command: 'stop', description: 'Stop a registered session — /stop <slug>' },
+    { command: 'status', description: 'Show active sessions and their state' },
+    { command: 'compact', description: 'Compact context on the fronted session' },
+    { command: 'cost', description: 'Show Max 20x usage + weekly burn' },
+    { command: 'rewind', description: 'Rewind the fronted session by one user message' },
+];
+/**
+ * Route a parsed slash command to its handler. Returns undefined for
+ * unknown commands so the caller can fall back to "unknown command" UX.
+ */
+export function dispatchCommand(parsed, ctxBase) {
+    const handler = COMMAND_HANDLERS[parsed.cmd];
+    if (!handler)
+        return undefined;
+    return handler({ ...ctxBase, args: parsed.args });
+}
+//# sourceMappingURL=commands.js.map