@a1hvdy/cc-openclaw 0.27.2 → 0.27.6

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

@@ -15,6 +15,14 @@
  */
 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"
@@ -36,28 +44,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

@@ -14,7 +14,7 @@
  * Tests live at tests/channels/telegram-mirror/m2-render-pipeline.test.ts.
  */
 import { renderStatusLine, renderMeters, renderTodos } from './status-line.js';
-import { escapeHtml, code, pre, markdownToHtml } from '../../lib/html-render.js';
+import { escapeHtml, code, pre, markdownToHtml, closeDanglingTags } from '../../lib/html-render.js';
 // v0.27.0 M1 — the card renders as Telegram HTML (parse_mode: 'HTML'), not
 // MarkdownV2. HTML only needs `& < >` escaped (no per-char backslash litter)
 // and supports <pre><code class="language-…"> + <blockquote> for true
@@ -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,112 @@ 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);
+}
+/**
+ * v0.27.5 — extension → Telegram syntax-highlight language. Telegram's only
+ * source of color is `<pre><code class="language-X">`; this maps a file
+ * extension to the `X` it recognizes. Unlisted extensions fall through to
+ * `undefined` (classless block, exactly as today).
+ */
+const EXT_LANG = {
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    sh: 'bash',
+    json: 'json',
+    md: 'markdown',
+    yml: 'yaml',
+    yaml: 'yaml',
+    sql: 'sql',
+    go: 'go',
+    rs: 'rust',
+    css: 'css',
+    html: 'html',
+    toml: 'toml',
+};
+/**
+ * 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 function langForTool(tc) {
+    const n = tc.name.toLowerCase();
+    if (n === 'bash' || n === 'shell')
+        return 'bash';
+    const input = tc.input;
+    if (input && typeof input === 'object' && typeof input.file_path === 'string') {
+        const m = /\.([a-z0-9]+)$/i.exec(input.file_path);
+        if (m)
+            return EXT_LANG[m[1].toLowerCase()];
+    }
+    return undefined;
+}
 /**
  * Format one tool-call line for inclusion in the rendered card body.
  *   "✓ Bash · ls -la"
@@ -171,11 +282,14 @@ export function renderThinkingBlock(thinkingText) {
     // v0.27.0 M1 — Telegram HTML <blockquote> renders the reasoning as a single
     // indented quote (terminal-style), distinct from the assistant text. Content
     // is HTML-escaped; newlines are preserved inside the blockquote.
+    // v0.27.5 M3 — `expandable` collapses long reasoning to a tap-to-expand quote,
+    // keeping the card compact. stripHtml's `blockquote\b[^>]*>` already tolerates
+    // the attribute, so the plain-text fallback is unaffected.
     const body = trimmed
         .split('\n')
         .map((l) => escapeHtml(l))
         .join('\n');
-    return `💭 Thinking\n<blockquote>${body}</blockquote>`;
+    return `💭 Thinking\n<blockquote expandable>${body}</blockquote>`;
 }
 /**
  * Render the full turn into a Telegram-safe message body. The mirror keeps
@@ -199,8 +313,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 +343,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 +362,114 @@ 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, 'diff') // v0.27.5 M1 — Telegram colors -/+ lines red/green
+                : resultText
+                    ? pre(truncateResult(resultText), langForTool(tc)) // v0.27.5 M2 — lang-highlight output
+                    : '';
+            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).
+    const body = lines.join('\n');
+    if (body.length <= 4096)
+        return body;
+    // v0.27.5 M4 — a blunt slice can split an HTML tag, which makes Telegram reject
+    // the edit and forces editTg's plain-text fallback (the path that surfaces
+    // literal `<pre>`/`**`/`- ` markup — the exact "raw markdown" leak we're
+    // closing). Instead: truncate at the last whole line ≤ 4090, close any tag the
+    // slice left dangling (LIFO), then append the ellipsis. The result is always
+    // well-formed HTML, so editTg never has to fall back. The 3900 budget means
+    // this rarely fires, but it must be safe when it does.
+    const hard = body.slice(0, 4090);
+    const nl = hard.lastIndexOf('\n');
+    const sliced = nl > 0 ? hard.slice(0, nl) : hard;
+    return closeDanglingTags(sliced) + '\n…';
 }
 /**
  * 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

@@ -358,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,
@@ -370,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.js

@@ -392,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;

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
@@ -79,7 +90,7 @@ export declare function pushAssistantText(text: string): void;
  * into the card during the turn, then calls this on turn end. Single-tenant:
  * finalizes ALL active cards (one at a time in practice).
  */
-export declare function finalizeActiveCards(): Promise<void>;
+export declare function finalizeActiveCards(deliveredText?: string): Promise<void>;
 /**
  * Map a caught error to a short, user-readable card reason (v0.27.0 M4). Keeps
  * the "❌ <reason>" header concise and classifies the common cc-openclaw-side

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
@@ -241,7 +272,7 @@ export function pushAssistantText(text) {
  * into the card during the turn, then calls this on turn end. Single-tenant:
  * finalizes ALL active cards (one at a time in practice).
  */
-export async function finalizeActiveCards() {
+export async function finalizeActiveCards(deliveredText) {
     const chats = activeChatIds();
     if (chats.length === 0)
         return;
@@ -260,7 +291,15 @@ export async function finalizeActiveCards() {
             // The plugin can't suppress the gateway reply (no suppressUserDelivery
             // knob), so the card yields the final text and finalizes to a clean
             // status/tools/✓ Done activity view. renderTurn itself is unchanged.
-            turn.assistantText = '';
+            //
+            // v0.27.6 disconnect exception (Killer #2 report-drop) — when the gateway
+            // socket died mid-turn the gateway delivers NOTHING separately, so the
+            // dedup assumption breaks and wiping the text yields total silence
+            // ("✓ Done" then nothing). The caller passes the accumulated text in that
+            // case (deliveredText); the finalized card then KEEPS the full report as
+            // the sole delivery channel. On the happy path deliveredText is undefined
+            // → '' → behavior unchanged (gateway delivers, no duplicate).
+            turn.assistantText = deliveredText ?? '';
             try {
                 await editTg(chatId, card.messageId, renderTurn(turn, card.meta));
             }

package/dist/src/constants.d.ts

@@ -36,6 +36,16 @@ export declare const TURN_TIMEOUT_MS = 900000;
 export declare const STALLED_SESSION_KILL_MS = 180000;
 /** How often the stalled-session watchdog scans the sessions Map. */
 export declare const STALLED_WATCH_INTERVAL_MS = 30000;
+/** v0.27.4 (M4/M6) — resume-freshness window for openai-compat sessions.
+ *  After a gateway restart OR a stalled-session watchdog SIGTERM, the in-process
+ *  session object is gone; without this, the next turn for the same chat spawns
+ *  a FRESH Claude conversation (no --resume) and the user loses all context.
+ *  When an openai-compat session opts in (config.resumeFreshnessMs), the next
+ *  turn resumes the prior Claude session ONLY if it was active within this
+ *  window — older sessions start fresh, preserving the anti-stale intent that
+ *  motivated skipPersistence. Default 30 min; env-overridable at the use site
+ *  via CC_OPENCLAW_RESUME_FRESHNESS_MS. */
+export declare const RESUME_FRESHNESS_MS = 1800000;
 /** Runaway-loop watchdog: max new cc-openclaw subprocess spawns within
  *  RUNAWAY_LOOP_WINDOW_MS before the next spawn is refused.
  *
@@ -176,3 +186,20 @@ export declare const CC_AUTO_COMPACT_THRESHOLD = 70;
  *  recreate) instead of compacting. Used when /compact itself would leave
  *  the session too close to the model's window cap to do useful work. */
 export declare const CC_HARD_RESET_THRESHOLD = 90;
+/** Single-flight window for the openai-compat streaming path. When two
+ *  requests with a byte-identical (sessionName + input) signature arrive
+ *  within this window, the second is treated as a duplicate (an OpenClaw
+ *  retry of a stream it perceived as dead) and JOINS the in-flight turn
+ *  instead of spawning a SECOND full model run. The leader's result is
+ *  replayed to the follower; the model executes exactly once.
+ *
+ *  Born from the 2026-05-22 incident: an OOM SIGKILL (exit 137) made
+ *  OpenClaw retry, and session-manager's per-session send-chain SERIALIZES
+ *  (rather than coalesces) the retry — so the turn ran twice and delivered
+ *  two identical Telegram messages. This guards the duplicate at its source.
+ *
+ *  Set CC_OPENCLAW_DEDUP_WINDOW_MS=0 to disable (pure fail-open to the prior
+ *  serialize-and-rerun behavior). Default 45s comfortably exceeds a typical
+ *  OpenClaw read-timeout-then-retry gap without risking a real, distinct
+ *  follow-up message colliding with a just-finished identical one. */
+export declare const DEDUP_WINDOW_MS = 45000;

package/dist/src/constants.js

@@ -39,6 +39,16 @@ export const TURN_TIMEOUT_MS = 900_000;
 export const STALLED_SESSION_KILL_MS = 180_000;
 /** How often the stalled-session watchdog scans the sessions Map. */
 export const STALLED_WATCH_INTERVAL_MS = 30_000;
+/** v0.27.4 (M4/M6) — resume-freshness window for openai-compat sessions.
+ *  After a gateway restart OR a stalled-session watchdog SIGTERM, the in-process
+ *  session object is gone; without this, the next turn for the same chat spawns
+ *  a FRESH Claude conversation (no --resume) and the user loses all context.
+ *  When an openai-compat session opts in (config.resumeFreshnessMs), the next
+ *  turn resumes the prior Claude session ONLY if it was active within this
+ *  window — older sessions start fresh, preserving the anti-stale intent that
+ *  motivated skipPersistence. Default 30 min; env-overridable at the use site
+ *  via CC_OPENCLAW_RESUME_FRESHNESS_MS. */
+export const RESUME_FRESHNESS_MS = 1_800_000;
 /** Runaway-loop watchdog: max new cc-openclaw subprocess spawns within
  *  RUNAWAY_LOOP_WINDOW_MS before the next spawn is refused.
  *
@@ -185,3 +195,21 @@ export const CC_AUTO_COMPACT_THRESHOLD = 70;
  *  recreate) instead of compacting. Used when /compact itself would leave
  *  the session too close to the model's window cap to do useful work. */
 export const CC_HARD_RESET_THRESHOLD = 90;
+// ─── request coalescing / duplicate-turn defense (v0.27.5) ──────────────────
+/** Single-flight window for the openai-compat streaming path. When two
+ *  requests with a byte-identical (sessionName + input) signature arrive
+ *  within this window, the second is treated as a duplicate (an OpenClaw
+ *  retry of a stream it perceived as dead) and JOINS the in-flight turn
+ *  instead of spawning a SECOND full model run. The leader's result is
+ *  replayed to the follower; the model executes exactly once.
+ *
+ *  Born from the 2026-05-22 incident: an OOM SIGKILL (exit 137) made
+ *  OpenClaw retry, and session-manager's per-session send-chain SERIALIZES
+ *  (rather than coalesces) the retry — so the turn ran twice and delivered
+ *  two identical Telegram messages. This guards the duplicate at its source.
+ *
+ *  Set CC_OPENCLAW_DEDUP_WINDOW_MS=0 to disable (pure fail-open to the prior
+ *  serialize-and-rerun behavior). Default 45s comfortably exceeds a typical
+ *  OpenClaw read-timeout-then-retry gap without risking a real, distinct
+ *  follow-up message colliding with a just-finished identical one. */
+export const DEDUP_WINDOW_MS = 45_000;

package/dist/src/engines/persistent-session.d.ts

@@ -27,6 +27,11 @@ interface InternalStats {
     lastActivity: string | null;
     /** v0.27.x — last PROGRESS event ts (excludes api_retry); watchdog keys off it. */
     lastProgressAt: string | null;
+    /** v0.27.6 — count of tool calls currently in flight (dispatched onToolUse
+     *  without a matching onToolResult yet). The stalled-session watchdog treats
+     *  inFlightTools > 0 as "alive" so a long quiet Bash/build/test step is never
+     *  killed mid-run. Reset to 0 at turn boundaries (start / complete / close). */
+    inFlightTools: number;
     history: Array<{
         time: string;
         type: string;