@a1hvdy/cc-openclaw 0.27.1 → 0.27.4

package/dist/src/channels/telegram-mirror/askuser.js

@@ -23,6 +23,7 @@
 import { CallbackMap } from './callback-mapping.js';
 import { sendTg, editTg, telegramApi } from '../../lib/telegram-bot-api.js';
 import { escapeHtml } from '../../lib/html-render.js';
+import { probeInjectionEnqueued } from '../../lib/probes.js';
 /** 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 const ASKUSER_NS = 'ccmirror';
@@ -165,6 +166,7 @@ function injectAnswer(api, ctx, text) {
         return;
     }
     try {
+        probeInjectionEnqueued(sessionKey, 'askuser'); // P0-A (observe-only, gated)
         api.enqueueNextTurnInjection({
             sessionKey,
             text: `[User answered the AskUserQuestion]: ${text}`,

package/dist/src/channels/telegram-mirror/card-renderer.d.ts

@@ -15,6 +15,7 @@
  */
 import type { Turn, ToolCallRecord } from './state-machine.js';
 import type { CardMeta } from './card-state.js';
+export declare function toolDiffBlock(tc: ToolCallRecord): string;
 /**
  * Format one tool-call line for inclusion in the rendered card body.
  *   "✓ Bash · ls -la"
@@ -36,28 +37,6 @@ export declare function renderToolLine(tc: ToolCallRecord): string;
  * without depending on MarkdownV2 escapes. Empty thinking returns ''.
  */
 export declare function renderThinkingBlock(thinkingText: string): string;
-/**
- * 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 declare function renderTurn(turn: Turn, meta?: CardMeta): string;
 /**
  * A render action — abstraction the dispatch layer (added in a later

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

@@ -101,8 +101,13 @@ function toolResultText(tc) {
  * readable (Telegram's 4096-char message cap) while still surfacing tool output
  * the way the CLI shows it inline.
  */
-const RESULT_MAX_LINES = 3;
-const RESULT_MAX_CHARS = 200;
+// v0.27.4 M3 — CLI-parity gap #4: the prior 3-line/200-char cap was far stingier
+// than the terminal (which shows full, scrollable output). Raised to 10 lines/500
+// chars — a ~2.5× visibility gain that stays card-safe because renderTurn's
+// per-entry budget loop renders newest-first and collapses older tools to a
+// "… +N earlier" marker, so a single fat result can't starve the others.
+const RESULT_MAX_LINES = 10;
+const RESULT_MAX_CHARS = 500;
 function truncateResult(s) {
     const lines = s.split('\n');
     let cut = lines.length > RESULT_MAX_LINES;
@@ -113,6 +118,70 @@ function truncateResult(s) {
     }
     return cut ? out.replace(/\s+$/, '') + '\n…' : out;
 }
+/**
+ * v0.27.4 M2 — CLI-parity gap #3: render a compact file diff for Edit / Write /
+ * MultiEdit from the tool INPUT (the result payload is only "File updated", so
+ * the meaningful change is in old_string/new_string / content / edits[]). Mirrors
+ * the terminal's inline diff: `- removed` / `+ added` lines, capped for the card.
+ * Returns RAW text (caller wraps in a <pre> block, which HTML-escapes it). '' for
+ * non-edit tools or empty input (no-fake-data — never invents a diff).
+ */
+const DIFF_MAX_LINES = 8;
+const DIFF_MAX_CHARS = 320;
+function truncateDiff(lines) {
+    let cut = lines.length > DIFF_MAX_LINES;
+    let out = lines.slice(0, DIFF_MAX_LINES).join('\n');
+    if (out.length > DIFF_MAX_CHARS) {
+        out = out.slice(0, DIFF_MAX_CHARS);
+        cut = true;
+    }
+    return cut ? out.replace(/\s+$/, '') + '\n…' : out;
+}
+export function toolDiffBlock(tc) {
+    const n = tc.name.toLowerCase();
+    const input = tc.input;
+    if (!input || typeof input !== 'object')
+        return '';
+    const lines = [];
+    if (n === 'edit') {
+        const oldS = typeof input.old_string === 'string' ? input.old_string : '';
+        const newS = typeof input.new_string === 'string' ? input.new_string : '';
+        if (!oldS && !newS)
+            return '';
+        for (const l of oldS.split('\n'))
+            lines.push(`- ${l}`);
+        for (const l of newS.split('\n'))
+            lines.push(`+ ${l}`);
+    }
+    else if (n === 'multiedit') {
+        const edits = Array.isArray(input.edits) ? input.edits : [];
+        if (edits.length === 0)
+            return '';
+        lines.push(`~ ${edits.length} edit${edits.length === 1 ? '' : 's'}`);
+        const first = edits[0];
+        if (first) {
+            const oldS = typeof first.old_string === 'string' ? first.old_string : '';
+            const newS = typeof first.new_string === 'string' ? first.new_string : '';
+            for (const l of oldS.split('\n'))
+                lines.push(`- ${l}`);
+            for (const l of newS.split('\n'))
+                lines.push(`+ ${l}`);
+        }
+    }
+    else if (n === 'write') {
+        const content = typeof input.content === 'string' ? input.content : '';
+        if (!content)
+            return '';
+        const contentLines = content.split('\n');
+        lines.push(`+ new file (${contentLines.length} line${contentLines.length === 1 ? '' : 's'})`);
+        for (const l of contentLines)
+            lines.push(`+ ${l}`);
+    }
+    else {
+        return '';
+    }
+    return truncateDiff(lines);
+}
 /**
  * Format one tool-call line for inclusion in the rendered card body.
  *   "✓ Bash · ls -la"
@@ -199,8 +268,27 @@ export function renderThinkingBlock(thinkingText) {
  * Lines with no content (e.g. empty tool list, empty assistant text) are
  * omitted entirely so the rendered body never has trailing whitespace.
  */
+/**
+ * Telegram hard-caps a single message at 4096 chars; an edit that exceeds it is
+ * rejected outright (and editTg's fallback can't help — same oversized text).
+ * v0.27.3: budget the rendered body. v0.27.0 M2 began emitting a
+ * <pre><code> result block under every tool line, which on a heavy multi-tool
+ * turn (e.g. a 15-Bash version check) silently blew past 4096 → every edit
+ * failed → the card froze as a bare "✓ Done" with no activity. The fix renders a
+ * GUARANTEED spine (status + header + tool LINES) first, then adds the richer,
+ * droppable blocks (result previews, todos, thinking, assistant text) only while
+ * budget remains. The card therefore always shows the tool activity.
+ */
+const TG_BODY_BUDGET = 3900; // margin under the 4096 hard cap (entities + safety)
 export function renderTurn(turn, meta) {
     const lines = [];
+    // Running length tracker (string.length + the join newline). O(1) per push;
+    // avoids re-joining the array on every budget check.
+    let used = 0;
+    const push = (s) => {
+        lines.push(s);
+        used += s.length + 1;
+    };
     // v0.26.2 M1 — CC-CLI-style status line at the top (model · CC ver · ⏱ · 🔧 ·
     // bypass). Gated on `meta` presence so legacy no-meta callers (and the initial
     // pre-model inbound card) render exactly as before — no regression. Once the
@@ -210,17 +298,17 @@ export function renderTurn(turn, meta) {
         // v0.27.0 M1 — bold the status line (the card header) via HTML <b>. Content
         // HTML-escaped first ( & < > only — model/version dots & brackets are safe).
         if (status)
-            lines.push(`<b>${escapeHtml(status)}</b>`);
+            push(`<b>${escapeHtml(status)}</b>`);
         // v0.26.2 M2 — meter row (context % + quota % + reset). Same no-fake-data
         // gating: omitted unless real values are present. HTML-escaped for safety.
         const meters = renderMeters(meta);
         if (meters)
-            lines.push(escapeHtml(meters));
+            push(escapeHtml(meters));
         // v0.26.4 styling — divider between the status/telemetry block and the
         // activity block (only when a status block was actually rendered). The
         // heavy-bar glyph is not HTML-significant, so it needs no escaping.
         if (lines.length > 0)
-            lines.push('━━━━━━━━━━━━');
+            push('━━━━━━━━━━━━');
     }
     // Turn-status header. v0.27.0 M4 — a failed turn shows "❌ <reason>" so it
     // never dies as an eternal "…"; reason is HTML-escaped (it's an error message).
@@ -229,42 +317,106 @@ export function renderTurn(turn, meta) {
         : turn.state === 'done'
             ? '✓ Done'
             : '▶ Working';
-    lines.push(header);
+    push(header);
     if (turn.toolCalls.length > 0) {
-        for (const tc of turn.toolCalls) {
-            lines.push(renderToolLine(tc));
-            // v0.27.0 M2 — surface the tool's RESULT as a truncated <pre><code> block
-            // under its line (CLI-style inline output), when there's real text.
+        // Build tool ENTRIES (tool line + its optional <pre><code> result block)
+        // newest-first, keeping what fits under budget; the older overflow collapses
+        // to a "… +N earlier tools" marker. Budgeting the line AND its result block
+        // TOGETHER is the fix for the v0.27.0 regression: the prior code budgeted
+        // lines alone, then result blocks ate the remaining room and the leftover
+        // lines pushed unguarded — bursting Telegram's 4096 cap. Reserve TAIL_RESERVE
+        // so the assistant text / todos / thinking below always have somewhere to go.
+        const TAIL_RESERVE = 700;
+        const cap = TG_BODY_BUDGET - TAIL_RESERVE;
+        const entries = []; // oldest→newest display order
+        let shown = 0;
+        let acc = 0;
+        for (let i = turn.toolCalls.length - 1; i >= 0; i--) {
+            const tc = turn.toolCalls[i];
+            const line = renderToolLine(tc);
+            // v0.27.4 M2 — for Edit/Write/MultiEdit show a diff (from input) instead of
+            // the "File updated" result; other tools keep the result preview.
+            const diffText = toolDiffBlock(tc);
             const resultText = toolResultText(tc);
-            if (resultText)
-                lines.push(pre(truncateResult(resultText)));
+            const block = diffText
+                ? pre(diffText)
+                : resultText
+                    ? pre(truncateResult(resultText))
+                    : '';
+            const withBlock = block ? `${line}\n${block}` : line;
+            // Prefer line+block; if that bursts the cap, fall back to the line alone
+            // (the result preview is the droppable part, the activity line is not).
+            if (used + acc + withBlock.length + 1 <= cap) {
+                entries.unshift(withBlock);
+                acc += withBlock.length + 1;
+                shown++;
+            }
+            else if (used + acc + line.length + 1 <= cap) {
+                entries.unshift(line);
+                acc += line.length + 1;
+                shown++;
+            }
+            else {
+                break; // no room for even the bare line → stop; rest become "+N earlier"
+            }
         }
+        const hidden = turn.toolCalls.length - shown;
+        if (hidden > 0)
+            push(`… +${hidden} earlier tool${hidden === 1 ? '' : 's'}`);
+        for (const e of entries)
+            push(e);
     }
     // v0.26.2 M4 — todo checklist (real data from the agent's TodoWrite calls).
     // Escaped as a block (glyphs are safe; content + the "+N more" plus sign are
     // not, so the whole block goes through the escaper).
     const todoBlock = renderTodos(meta);
     if (todoBlock) {
-        lines.push('');
-        lines.push(escapeHtml(todoBlock));
+        const block = escapeHtml(todoBlock);
+        if (used + block.length + 2 <= TG_BODY_BUDGET) {
+            push('');
+            push(block);
+        }
     }
     // 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);
+    if (thinking.length > 0 && used + thinking.length + 2 <= TG_BODY_BUDGET) {
+        push('');
+        push(thinking);
     }
     const text = turn.assistantText.trim();
     if (text.length > 0) {
-        lines.push('');
         // v0.27.0 M1 — render the model's markdown as Telegram HTML with structure
         // preserved (**bold**→<b>, `code`→<code>, ```bash fences→<pre><code
         // class="language-bash">). HTML-escapes all remaining content (& < >).
-        lines.push(markdownToHtml(text));
+        // Budget-aware: if the full text won't fit, render a truncated head so the
+        // card still ends with readable context rather than dropping it entirely.
+        const room = TG_BODY_BUDGET - used - 2;
+        if (room > 0) {
+            const full = markdownToHtml(text);
+            if (full.length <= room) {
+                push('');
+                push(full);
+            }
+            else if (room > 240) {
+                // Truncate the SOURCE before markdown→HTML so we never split an HTML tag
+                // mid-emit (which would break Telegram's parser). Leave slack for the "…".
+                const headSrc = text.slice(0, room - 40).replace(/\s+\S*$/, '');
+                push('');
+                push(markdownToHtml(headSrc) + '\n…');
+            }
+        }
     }
-    return lines.join('\n');
+    // Guaranteed safety net: even if the budgeted assembly above has a logic gap,
+    // a card MUST NOT exceed Telegram's 4096-char hard cap (an over-cap edit is
+    // rejected outright). A blunt slice here can split an HTML tag, but editTg's
+    // hardened plain-text fallback strips tags on rejection, so this degrades
+    // gracefully rather than freezing the card.
+    const body = lines.join('\n');
+    if (body.length <= 4096)
+        return body;
+    return body.slice(0, 4095) + '…';
 }
 /**
  * Decide whether the current turn snapshot should be sent (first render)

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

@@ -126,6 +126,22 @@ export declare function handleCancel(ctx: CommandContext): CommandResult;
  * 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>;
 /**

package/dist/src/channels/telegram-mirror/commands.js

@@ -98,17 +98,21 @@ export function handleNew(ctx) {
         };
     }
     const existing = getBySlug(slug);
-    // Session-name comes from the engine; M4 stores a placeholder that M5+ overwrites.
+    // Session-name comes from the engine when a real turn fronts this slug; until
+    // then we store a placeholder. The registry IS the real state that /sessions
+    // and /status read — so the confirmation reflects the actual registry count
+    // (planning D-5/D-2), not a false "engine wire-up lands in M5" promise.
     const sessionName = existing?.sessionName ?? `pending-${slug}-${Date.now()}`;
     register(slug, sessionName);
+    const total = list().length;
     return {
         actions: [
             {
                 type: 'sendMessage',
                 chat_id: ctx.chatId,
                 text: existing
-                    ? `Session "${slug}" already registered — fronted.`
-                    : `Session "${slug}" registered. Engine wire-up lands in M5.`,
+                    ? `Session "${slug}" already registered (${total} total). Open it from /sessions.`
+                    : `Session "${slug}" registered (${total} total). Open it from /sessions.`,
             },
         ],
     };
@@ -128,13 +132,14 @@ export function handleStop(ctx) {
         };
     }
     const removed = unregister(slug);
+    const remaining = list().length;
     return {
         actions: [
             {
                 type: 'sendMessage',
                 chat_id: ctx.chatId,
                 text: removed
-                    ? `Session "${slug}" stopped.`
+                    ? `Session "${slug}" stopped (${remaining} remaining).`
                     : `No registered session named "${slug}".`,
             },
         ],
@@ -166,16 +171,17 @@ export function handleStatus(ctx) {
 }
 // ── /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.
+    // D-6 (planning): honest stub. The Telegram bridge has no session-control
+    // primitive to trigger context compaction on the running session — the only
+    // plugin levers are enqueueNextTurnInjection (text, next-turn only) and
+    // registerInteractiveHandler. So /compact is CLI-only until/unless OpenClaw
+    // exposes a control primitive. Claiming "queued" would be a lie (it never runs).
     return {
         actions: [
             {
                 type: 'sendMessage',
                 chat_id: ctx.chatId,
-                text: '⏳ Compact queued — engine wire-up lands in M5.',
+                text: "⚠️ /compact is CLI-only — the Telegram bridge can't trigger context compaction (no session-control primitive). Run it from Claude Code directly.",
             },
         ],
     };
@@ -212,14 +218,15 @@ export function handleCost(ctx) {
 }
 // ── /rewind ──────────────────────────────────────────────────────────────
 export function handleRewind(ctx) {
-    // M4: queued — actual rewind walks the cc-handler resume path (deferred
-    // to M5 with the rest of engine bridging).
+    // D-6 (planning): honest stub — same rationale as /compact. Rewinding a
+    // running session needs a session-control primitive the plugin can't reach;
+    // it's CLI-only. "Queued" would never actually run, so we say so plainly.
     return {
         actions: [
             {
                 type: 'sendMessage',
                 chat_id: ctx.chatId,
-                text: '⏪ Rewind queued — engine wire-up lands in M5.',
+                text: "⚠️ /rewind is CLI-only — the Telegram bridge can't rewind a session (no session-control primitive). Run it from Claude Code directly.",
             },
         ],
     };
@@ -351,6 +358,38 @@ export function handleSoakCheck(ctx) {
         ],
     };
 }
+// ── /help (v0.27.4 M7 — CLI-parity gap #6) ───────────────────────────────
+/**
+ * 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 const ALL_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: 'cost', description: 'Show Max 20x usage + weekly burn' },
+    { command: 'compact', description: 'Compact context (CLI-only — see note)' },
+    { command: 'rewind', description: 'Rewind a session (CLI-only — see note)' },
+    { command: 'compose', description: 'Start a multi-message draft — finish with /send' },
+    { command: 'send', description: 'Send the composed draft to Claude' },
+    { command: 'cancel', description: 'Cancel the active compose draft' },
+    { command: 'help', description: 'Show this command list' },
+];
+/**
+ * /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 function handleHelp(ctx) {
+    const lines = ['<b>cc-openclaw Telegram commands</b>', ''];
+    for (const c of ALL_COMMANDS)
+        lines.push(`/${c.command} — ${c.description}`);
+    lines.push('', 'Any other slash command or message is sent straight to Claude.');
+    return { actions: [{ type: 'sendMessage', chat_id: ctx.chatId, text: lines.join('\n') }] };
+}
 export const COMMAND_HANDLERS = {
     sessions: handleSessions,
     new: handleNew,
@@ -363,6 +402,8 @@ export const COMMAND_HANDLERS = {
     send: handleSend,
     cancel: handleCancel,
     'soak-check': handleSoakCheck,
+    help: handleHelp,
+    commands: handleHelp,
 };
 /**
  * Telegram bot commands list — declarative source for M5's setMyCommands sync.

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

@@ -22,9 +22,14 @@
  * 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?: {
@@ -50,6 +55,19 @@ export interface HandlerState {
     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/inbound-handler.js

@@ -23,13 +23,14 @@
  * resolution and compose state survive across handler invocations.
  */
 import { dispatchCommand, parseSlash, COMMAND_HANDLERS } from './commands.js';
-import { sendTg, editTg } from '../../lib/telegram-bot-api.js';
+import { sendTg, editTg, sendDocumentTg } from '../../lib/telegram-bot-api.js';
 import { CallbackMap } from './callback-mapping.js';
 import { ComposeBuffer } from './compose-buffer.js';
 import { TurnStateMachine } from './state-machine.js';
 import { renderTurn } from './card-renderer.js';
 import { cardState as _cardState, cardStateDebug } from './card-state.js';
 import { handleTap, handleTapData, isAskUserCallback, rememberSessionKey, ASKUSER_NS, } from './askuser.js';
+import { probeInboundShape, probeToolUse } from '../../lib/probes.js';
 const PLUGIN_TAG = '[cc-openclaw/telegram-mirror/inbound]';
 // v0.26.3 M5 — register the AskUserQuestion interactive tap handler exactly
 // once per process (registerInboundHandler runs on every register() call).
@@ -76,12 +77,15 @@ const MIRROR_COMMANDS = new Set(Object.keys(COMMAND_HANDLERS));
 /**
  * Forward a single TelegramAction to the actual Telegram API. Returns
  * the API response (or {ok:false} on failure). Pure I/O — no state
- * mutation.
+ * mutation. Exported for unit testing (planning M-B/B2).
  *
- * editMessageText and sendDocument variants land in v0.25.2 when the
- * render pipeline and plan-attachment dispatch wire up.
+ * 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.
  */
-async function forwardAction(action, threadId, logger) {
+export async function forwardAction(action, threadId, logger) {
     try {
         if (action.type === 'sendMessage') {
             await sendTg(String(action.chat_id), action.text, threadId !== undefined ? String(threadId) : undefined, action.reply_markup);
@@ -91,8 +95,15 @@ async function forwardAction(action, threadId, logger) {
             await editTg(String(action.chat_id), action.message_id, action.text, action.reply_markup);
             return;
         }
-        // sendDocument: v0.25.2 — plan-mode attachment wire-up.
-        logger.warn(`${PLUGIN_TAG} action type "${action.type}" not yet forwarded (deferred to v0.25.2)`);
+        if (action.type === 'sendDocument') {
+            await sendDocumentTg(String(action.chat_id), action.filename, action.content, {
+                caption: action.caption,
+                replyMarkup: action.reply_markup,
+                threadId,
+            });
+            return;
+        }
+        logger.warn(`${PLUGIN_TAG} action type "${action.type}" not forwarded (no handler)`);
     }
     catch (err) {
         logger.warn(`${PLUGIN_TAG} forwardAction failed: ${err.message}`);
@@ -205,6 +216,7 @@ export function registerInboundHandler(api, state = createHandlerState()) {
         // Per-event-id dedup at dispatch layer (purpose=slash).
         if (_seenOrMark('slash', _eventId(event)))
             return undefined;
+        probeInboundShape(event); // P0-C inbound surface (observe-only, gated)
         // Extract text from the canonical (2026.5.x) `event.content` field;
         // fall back to legacy nested paths if a future gateway version reverts.
         const text = (typeof event.content === 'string' ? event.content : undefined) ??
@@ -380,7 +392,7 @@ export function registerInboundHandler(api, state = createHandlerState()) {
         if (parsed && MIRROR_COMMANDS.has(parsed.cmd))
             return undefined;
         const fromKey = chatIdFromSessionKey(event.sessionKey);
-        let chatId = fromKey.chatId || (event.senderId !== undefined ? String(event.senderId) : '');
+        const chatId = fromKey.chatId || (event.senderId !== undefined ? String(event.senderId) : '');
         if (!chatId)
             return undefined;
         const threadId = fromKey.threadId !== undefined ? fromKey.threadId : event.raw?.message?.message_thread_id;
@@ -413,6 +425,7 @@ export function registerInboundHandler(api, state = createHandlerState()) {
         const event = args[0];
         dumpShapeOnce('before_tool_call', event);
         const ev = event;
+        probeToolUse(ev); // P0-B ExitPlanMode detection (observe-only, gated)
         const evId = _eventId({ sessionKey: (ev?.sessionKey ?? ev?.ctx?.['SessionKey']), timestamp: ev?.timestamp, content: `tool_use:${String((ev?.id ?? ev?.tool_use_id ?? ''))}` });
         if (_seenOrMark('tool_use', evId))
             return undefined;

package/dist/src/channels/telegram-mirror/turn-bridge.d.ts

@@ -66,6 +66,17 @@ export declare function pushToolResult(toolUseId: string | undefined, output: un
  * don't hammer Telegram with edits.
  */
 export declare function pushAssistantText(text: string): void;
+/**
+ * Record extended-thinking text on every active card (v0.27.4 M1 — CLI-parity
+ * gap #1). The streaming handler calls this from its `onThinking` callback as
+ * reasoning deltas arrive, passing the CUMULATIVE buffer (not the delta) — so
+ * the live card grows a 💭 block exactly the way the terminal streams thinking
+ * before the answer. Overwrites turn.thinkingText (same pattern as
+ * pushAssistantText), debounced repaint. Only fires while surfaceThinking is on
+ * (the handler gates the callback), so card-thinking matches the CLI's
+ * thinking-visibility setting rather than leaking reasoning unconditionally.
+ */
+export declare function pushThinking(text: string): void;
 /**
  * Finalize every active card at the END of a model turn. Flips each card's
  * turn to 'done' (so renderTurn shows "✓ Done"), repaints once, and removes

package/dist/src/channels/telegram-mirror/turn-bridge.js

@@ -113,6 +113,7 @@ export function readQuotaMeta() {
 // low-frequency, so log every call (including the cards=0 failure case, logged
 // BEFORE the early return). pushAssistantText is per-chunk, so throttle it.
 let _lastTextLogAt = 0;
+let _lastThinkLogAt = 0;
 function logPush(kind, cards, extra) {
     process.stderr.write(`[cc-openclaw/turn-bridge] ${kind} pid=${process.pid} ${cardStateDebug()}${extra}\n`);
 }
@@ -228,6 +229,36 @@ export function pushAssistantText(text) {
         void repaint(chatId, /* force */ false);
     }
 }
+/**
+ * Record extended-thinking text on every active card (v0.27.4 M1 — CLI-parity
+ * gap #1). The streaming handler calls this from its `onThinking` callback as
+ * reasoning deltas arrive, passing the CUMULATIVE buffer (not the delta) — so
+ * the live card grows a 💭 block exactly the way the terminal streams thinking
+ * before the answer. Overwrites turn.thinkingText (same pattern as
+ * pushAssistantText), debounced repaint. Only fires while surfaceThinking is on
+ * (the handler gates the callback), so card-thinking matches the CLI's
+ * thinking-visibility setting rather than leaking reasoning unconditionally.
+ */
+export function pushThinking(text) {
+    const chats = activeChatIds();
+    const now = Date.now();
+    if (chats.length === 0 || now - _lastThinkLogAt > 1500) {
+        _lastThinkLogAt = now;
+        logPush('pushThinking', chats.length, ` len=${text.length}`);
+    }
+    if (chats.length === 0)
+        return;
+    for (const chatId of chats) {
+        const card = cardState.get(chatId);
+        if (!card)
+            continue;
+        const turn = card.sm.getTurn(chatId);
+        if (!turn || turn.state !== 'working')
+            continue;
+        turn.thinkingText = text;
+        void repaint(chatId, /* force */ false);
+    }
+}
 /**
  * Finalize every active card at the END of a model turn. Flips each card's
  * turn to 'done' (so renderTurn shows "✓ Done"), repaints once, and removes