@clawling/clawchat-plugin-openclaw 2026.5.12-32 → 2026.5.12-39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.5.12-32",
+  "version": "2026.5.12-39",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "files": [

package/skills/clawchat/SKILL.md

@@ -13,6 +13,7 @@ This skill guides agent behavior for ClawChat-aware tasks. Use the registered Cl
 
 - Use registered ClawChat plugin tools for account/profile, friends, users, moments, comments, reactions, avatar, media, and read-only conversation lookup.
 - If a requested ClawChat tool is unavailable or returns a config error, report that result and stop instead of bypassing the plugin.
+- Use the `/clawchat-output` slash command when the user asks to change how much ClawChat runtime output is shown in the current conversation.
 
 ## OpenClaw CLI
 
@@ -30,6 +31,18 @@ Use `update --force` only when local ClawChat plugin or skill files look corrupt
 
 If `channels add` reports `Unknown channel: clawchat-plugin-openclaw`, use the runtime slash command `/clawchat-activate CODE` after the operator ensures the plugin is loaded.
 
+## Output Visibility
+
+When the user asks to change ClawChat output verbosity, use the runtime slash command for the current conversation. Treat natural-language wording as aliases for the three supported modes:
+
+| User wording | Command |
+| --- | --- |
+| quiet mode, silent mode, minimal output, final-only output, `minimal` | `/clawchat-output minimal` |
+| conversation mode, normal mode, regular mode, default output, `normal` | `/clawchat-output normal` |
+| dev mode, developer mode, verbose mode, full output, `full` | `/clawchat-output full` |
+
+Do not edit config files directly for this request. If the slash command returns an error, report that error instead of claiming the mode changed.
+
 ## Plugin Tool Routing
 
 Tool descriptions are authoritative. These routing hints resolve common ambiguity:
@@ -57,7 +70,6 @@ Tool descriptions are authoritative. These routing hints resolve common ambiguit
 | Reply to an existing comment | `clawchat_reply_moment_comment` with `replyToCommentId` |
 | Delete a comment/reply | `clawchat_delete_moment_comment` with exact `momentId` and `commentId` |
 | Nickname or bio update | `clawchat_update_account_profile` |
-| Standalone shareable media URL | `clawchat_upload_media_file` |
 
 ## Profile And Identity Sync
 

package/src/api-client.ts

@@ -69,7 +69,7 @@ export interface OpenclawClawlingApiClient {
   uploadMedia(params: { buffer: Buffer; filename: string; mime?: string }): Promise<UploadResult>;
   /**
    * Exchange an invite code for an agent token.
-   * Request body shape: `{ code, platform, type }`.
+   * Request body shape: `{ code, platform, type, user_id? }`.
    */
   agentsConnect(params: {
     /** The invite code entered by the operator. */
@@ -78,6 +78,8 @@ export interface OpenclawClawlingApiClient {
     platform: string;
     /** Agent type tag (e.g. "bot"). */
     type: string;
+    /** Existing configured ClawChat user id, when re-activating an account. */
+    user_id?: string;
   }): Promise<AgentConnectResult>;
   /**
    * Upload an avatar image via `POST /v1/files/upload-url`. The resulting
@@ -423,7 +425,7 @@ export function createOpenclawClawlingApiClient(opts: ApiClientOptions): Opencla
         },
       );
     },
-    async agentsConnect({ code: inviteCode, platform, type }): Promise<AgentConnectResult> {
+    async agentsConnect({ code: inviteCode, platform, type, user_id: userId }): Promise<AgentConnectResult> {
       if (!inviteCode?.trim()) {
         throw new ClawlingApiError("validation", "agentsConnect: inviteCode is required");
       }
@@ -433,14 +435,18 @@ export function createOpenclawClawlingApiClient(opts: ApiClientOptions): Opencla
       if (!type?.trim()) {
         throw new ClawlingApiError("validation", "agentsConnect: type is required");
       }
+      const body: Record<string, string> = {
+        code: inviteCode.trim(),
+        platform: platform.trim(),
+        type: type.trim(),
+      };
+      if (userId?.trim()) {
+        body.user_id = userId.trim();
+      }
       return await call<AgentConnectResult>("POST", "/v1/agents/connect", {
         // `X-Device-Id` is added globally via `authHeaders` on every request.
         headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          code: inviteCode.trim(),
-          platform: platform.trim(),
-          type: type.trim(),
-        }),
+        body: JSON.stringify(body),
       });
     },
     async uploadMedia(params): Promise<UploadResult> {

package/src/client.ts

@@ -1,6 +1,8 @@
+import { createHash } from "node:crypto";
+import os from "node:os";
 import type { Envelope, Transport } from "./protocol-types.ts";
 import { createClawChatClient, type ClawlingChatClient } from "./ws-client.ts";
-import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
+import { CHANNEL_ID, type ResolvedOpenclawClawlingAccount } from "./config.ts";
 
 export type { ChatType } from "./protocol-types.ts";
 
@@ -15,6 +17,12 @@ export interface CreateClientOverrides {
   };
 }
 
+export function resolveOpenclawClawlingDeviceId(account: ResolvedOpenclawClawlingAccount): string {
+  const material = [CHANNEL_ID, account.accountId, account.userId, os.hostname()].join("\0");
+  const digest = createHash("sha256").update(material).digest("hex").slice(0, 24);
+  return `${CHANNEL_ID}-${digest}`;
+}
+
 export function createOpenclawClawlingClient(
   account: ResolvedOpenclawClawlingAccount,
   overrides: CreateClientOverrides = {},
@@ -22,7 +30,7 @@ export function createOpenclawClawlingClient(
   const client = createClawChatClient({
     url: account.websocketUrl,
     token: account.token,
-    deviceId: account.userId,
+    deviceId: resolveOpenclawClawlingDeviceId(account),
     ...(overrides.transport ? { transport: overrides.transport } : {}),
     reconnect: {
       enabled: true,

package/src/commands.ts

@@ -78,7 +78,7 @@ function persistOutputVisibility(
 function formatOutputVisibilityResult(outputVisibility: OutputVisibility): string {
   const detailLevel: Record<OutputVisibility, string> = {
     minimal: "final only",
-    normal: "final plus block media",
+    normal: "final plus block output",
     full: "final plus buffered reasoning, tool/progress, and block output",
   };
   return [

package/src/login.runtime.ts

@@ -202,10 +202,12 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
   runtime.log("Verifying invite code …");
   let result;
   try {
+    const existingUserId = account.userId.trim();
     result = await apiClient.agentsConnect({
       code: inviteCode,
       platform: AGENTS_CONNECT_PLATFORM,
       type: AGENTS_CONNECT_TYPE,
+      ...(existingUserId ? { user_id: existingUserId } : {}),
     });
   } catch (err) {
     if (err instanceof ClawlingApiError) {

package/src/reply-dispatcher.ts

@@ -69,6 +69,22 @@ type ClawChatReplyOptions = TypedReplyDispatcherResult["replyOptions"] &
   {
     sourceReplyDeliveryMode: "automatic";
     disableBlockStreaming: boolean;
+    suppressDefaultToolProgressMessages: boolean;
+    allowProgressCallbacksWhenSourceDeliverySuppressed?: boolean;
+    onReasoningStream?: (payload: ReplyPayload) => void | Promise<void>;
+    onToolStart?: (payload: {
+      name?: string;
+      phase?: string;
+      args?: Record<string, unknown>;
+      detailMode?: "explain" | "raw";
+    }) => void | Promise<void>;
+    onToolResult?: (payload: ReplyPayload) => void | Promise<void>;
+    onItemEvent?: (payload: Record<string, unknown>) => void | Promise<void>;
+    onPlanUpdate?: (payload: Record<string, unknown>) => void | Promise<void>;
+    onCommandOutput?: (payload: Record<string, unknown>) => void | Promise<void>;
+    onPatchSummary?: (payload: Record<string, unknown>) => void | Promise<void>;
+    onCompactionStart?: () => void | Promise<void>;
+    onCompactionEnd?: () => void | Promise<void>;
   };
 
 type RichAction = {
@@ -188,12 +204,171 @@ function resolvePayloadText(payload: ReplyPayload): string {
   return renderMessagePresentationFallbackText({ presentation, text: payload.text ?? null });
 }
 
+const FULL_OUTPUT_SUMMARY_MAX = 600;
+
+function truncateSummary(text: string): string {
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (compact.length <= FULL_OUTPUT_SUMMARY_MAX) return compact;
+  return `${compact.slice(0, FULL_OUTPUT_SUMMARY_MAX - 1).trimEnd()}…`;
+}
+
+function summarizeValue(value: unknown): string {
+  if (value == null) return "";
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return "";
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      if (parsed && typeof parsed === "object") return summarizeValue(parsed);
+    } catch {
+      // Plain text is already the best summary.
+    }
+    return truncateSummary(trimmed);
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `${value.length} item${value.length === 1 ? "" : "s"}`;
+  if (typeof value === "object") {
+    const keys = Object.keys(value as Record<string, unknown>).slice(0, 6);
+    return keys.length ? `object with ${keys.join(", ")}` : "object";
+  }
+  return truncateSummary(String(value));
+}
+
+function readStringField(payload: Record<string, unknown>, field: string): string {
+  const value = payload[field];
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function readPayloadCommand(payload: { args?: unknown }): string {
+  const args = payload.args;
+  if (!args || typeof args !== "object" || Array.isArray(args)) return "";
+  const command = (args as Record<string, unknown>).command;
+  return typeof command === "string" ? command.trim() : "";
+}
+
+function normalizeCommandLabel(value: string): string {
+  const trimmed = value.trim();
+  return trimmed.replace(/^command\s+/i, "").trim() || trimmed;
+}
+
+function isTerminalCommandOutput(payload: Record<string, unknown>): boolean {
+  const phase = readStringField(payload, "phase").toLowerCase();
+  const status = readStringField(payload, "status").toLowerCase();
+  return (
+    phase === "end" ||
+    phase === "error" ||
+    typeof payload.exitCode === "number" ||
+    status === "completed" ||
+    status === "ok" ||
+    status === "success" ||
+    status === "failed" ||
+    status === "error"
+  );
+}
+
+function isToolProgressItem(payload: Record<string, unknown>): boolean {
+  const kind = readStringField(payload, "kind").toLowerCase();
+  const title = readStringField(payload, "title").toLowerCase();
+  const name = readStringField(payload, "name").toLowerCase();
+  const progressText = readStringField(payload, "progressText").toLowerCase();
+  return (
+    kind === "tool" ||
+    kind === "command" ||
+    title.startsWith("exec ") ||
+    title.startsWith("command ") ||
+    name.startsWith("exec ") ||
+    name.startsWith("command ") ||
+    progressText.startsWith("exec ") ||
+    progressText.startsWith("command ")
+  );
+}
+
+function isDefaultToolResultText(text: string): boolean {
+  return /^[🛠🔧]/u.test(text.trim());
+}
+
+function summarizeProgressPayload(payload: Record<string, unknown>): string {
+  return (
+    readStringField(payload, "progressText") ||
+    readStringField(payload, "summary") ||
+    readStringField(payload, "message") ||
+    readStringField(payload, "title") ||
+    readStringField(payload, "name") ||
+    readStringField(payload, "status") ||
+    summarizeValue(payload)
+  );
+}
+
+function formatToolStartSummary(payload: {
+  name?: string;
+  phase?: string;
+  args?: unknown;
+}): string {
+  const name = payload.name?.trim() || "tool";
+  const phase = payload.phase?.trim();
+  if (phase && phase !== "start") return "";
+  const command = readPayloadCommand(payload);
+  if ((name === "exec" || name === "command") && !command) return "";
+  return `[tool] ${[name, command].filter(Boolean).join(" ")} started`;
+}
+
+function formatCommandOutputSummary(payload: Record<string, unknown>): string {
+  if (!isTerminalCommandOutput(payload)) return "";
+  const name = normalizeCommandLabel(
+    readStringField(payload, "title") || readStringField(payload, "name") || "command",
+  );
+  const status = readStringField(payload, "status").toLowerCase();
+  const visibleStatus =
+    status && status !== "ok" && status !== "completed" && status !== "success" ? status : "";
+  const exitCode = typeof payload.exitCode === "number" ? ` exit ${payload.exitCode}` : "";
+  const output = summarizeValue(payload.output);
+  const prefix = `[command] ${[name, visibleStatus].filter(Boolean).join(" ")}${exitCode}`;
+  return truncateSummary(output ? `${prefix}: ${output}` : prefix);
+}
+
+function formatPatchSummary(payload: Record<string, unknown>): string {
+  const summary = readStringField(payload, "summary");
+  if (summary) return `[patch] ${truncateSummary(summary)}`;
+  const parts: string[] = [];
+  for (const key of ["added", "modified", "deleted"]) {
+    const value = payload[key];
+    if (Array.isArray(value) && value.length > 0) parts.push(`${key}: ${value.map(String).join(", ")}`);
+    else if (typeof value === "number" && value > 0) parts.push(`${key}: ${value}`);
+  }
+  return `[patch] ${truncateSummary(parts.join("; ") || "updated")}`;
+}
+
+function formatItemEventSummary(payload: Record<string, unknown>): string {
+  const kind = readStringField(payload, "kind") || "progress";
+  const title = readStringField(payload, "title") || readStringField(payload, "name");
+  const status = readStringField(payload, "status");
+  const phase = readStringField(payload, "phase");
+  const summary = summarizeProgressPayload(payload);
+  const label = [title, status || phase].filter(Boolean).join(" ");
+  return `[${kind}] ${truncateSummary(label || summary || "activity")}`;
+}
+
+function formatPlanSummary(payload: Record<string, unknown>): string {
+  const title = readStringField(payload, "title") || "plan";
+  const explanation = readStringField(payload, "explanation");
+  const steps = Array.isArray(payload.steps) ? payload.steps.map(String).filter(Boolean) : [];
+  return `[plan] ${truncateSummary([title, explanation, ...steps].filter(Boolean).join(": "))}`;
+}
+
+function formatApprovalSummary(payload: Record<string, unknown>): string {
+  const title = readStringField(payload, "title") || readStringField(payload, "kind") || "approval";
+  const status = readStringField(payload, "status") || readStringField(payload, "phase");
+  const message = readStringField(payload, "message") || readStringField(payload, "reason");
+  return `[approval] ${truncateSummary([title, status, message].filter(Boolean).join(" "))}`;
+}
+
 /**
  * Reply dispatcher for clawchat-plugin-openclaw.
  *
  * ClawChat emits only materialized `message.send` / `message.reply` frames for
- * the final reply. Non-final OpenClaw deliveries are ignored or buffered
- * according to outputVisibility and are never sent as separate ClawChat frames.
+ * complete OpenClaw output units. `disableBlockStreaming` prevents token/block
+ * streaming; full visibility still forwards complete tool/progress/output units
+ * as separate ClawChat messages.
  */
 export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOptions): {
   dispatcher: TypedReplyDispatcherResult["dispatcher"];
@@ -213,6 +388,8 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   } = options;
   const isGroupTarget = target.chatType === "group";
   const outputVisibility = effectiveOutputVisibility(account, target.chatId, target.chatType);
+  const splitFullOutput = outputVisibility === "full";
+  const splitNormalBlockOutput = outputVisibility === "normal";
   const ownerDirectTarget = () => {
     const ownerUserId = account.ownerUserId?.trim();
     return ownerUserId ? { chatId: ownerUserId, chatType: "direct" as const } : null;
@@ -245,10 +422,13 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
 
   let reasoningText = "";
   let bufferedOutputText = "";
+  const bufferedOutputLineSet = new Set<string>();
+  const emittedFullSegmentSet = new Set<string>();
   const bufferedOutputUrls: string[] = [];
   let runDone = false;
   let typingActive = false;
   let terminalReplySuppressed = false;
+  let finalDeliverySeen = false;
 
   const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
   const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
@@ -331,13 +511,13 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     recordOutbound("thinking", messageId, thinkingText);
     reasoningText = "";
   };
-  const resetBufferedOutput = () => {
-    bufferedOutputText = "";
-    bufferedOutputUrls.length = 0;
-  };
   const appendBufferedText = (value: string) => {
     const trimmed = value.trim();
     if (!trimmed) return;
+    if (!trimmed.includes("\n")) {
+      if (bufferedOutputLineSet.has(trimmed)) return;
+      bufferedOutputLineSet.add(trimmed);
+    }
     bufferedOutputText = bufferedOutputText ? `${bufferedOutputText}\n${trimmed}` : trimmed;
   };
   const appendBufferedUrls = (urls: string[]) => {
@@ -345,12 +525,17 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       if (url && !bufferedOutputUrls.includes(url)) bufferedOutputUrls.push(url);
     }
   };
+  const fullSegmentKey = (text: string, urls: string[]): string =>
+    JSON.stringify({
+      text: text.replace(/\s+/g, " ").trim(),
+      urls: urls.filter(Boolean),
+    });
   const mergeFinalText = (text: string): string => {
-    if (outputVisibility !== "full") return text;
+    if (outputVisibility === "minimal" || outputVisibility === "full") return text;
     return [bufferedOutputText.trim(), text.trim()].filter(Boolean).join("\n");
   };
   const mergeFinalUrls = (urls: string[]): string[] => {
-    if (outputVisibility === "minimal") return urls;
+    if (outputVisibility === "minimal" || outputVisibility === "full") return urls;
     const merged = bufferedOutputUrls.slice();
     for (const url of urls) {
       if (url && !merged.includes(url)) merged.push(url);
@@ -485,15 +670,42 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     return result;
   };
 
+  const emitFullSegment = async (text: string, urls: string[] = []): Promise<void> => {
+    if (outputVisibility !== "full" && !splitNormalBlockOutput) {
+      appendBufferedText(text);
+      appendBufferedUrls(urls);
+      return;
+    }
+    if (!splitFullOutput && !splitNormalBlockOutput) {
+      appendBufferedText(text);
+      appendBufferedUrls(urls);
+      return;
+    }
+    const trimmed = text.trim();
+    if (!trimmed && urls.length === 0) return;
+    const segmentKey = fullSegmentKey(trimmed, urls);
+    if (emittedFullSegmentSet.has(segmentKey)) return;
+    emittedFullSegmentSet.add(segmentKey);
+    const mediaFragments = await uploadMediaUrls(urls);
+    await sendStatic(trimmed, mediaFragments, [], { recordMessage: true });
+  };
+
+  const emitFullRuntimeText = async (
+    label: string,
+    text: string,
+    urls: string[] = [],
+  ): Promise<void> => {
+    const summary = summarizeValue(text);
+    if (!summary && urls.length === 0) return;
+    await emitFullSegment(summary ? `[${label}] ${summary}` : "", urls);
+  };
+
   // ----- Dispatcher -------------------------------------------------------
 
   const base = runtime.channel.reply.createReplyDispatcherWithTyping({
     humanDelay,
     onReplyStart: async () => {
       emitTyping(true);
-      reasoningText = "";
-      resetBufferedOutput();
-      runDone = false;
     },
     deliver: async (payload: ReplyPayload, info?: { kind: "tool" | "block" | "final" }) => {
       if (consumeTerminalSend(info?.kind ?? "unknown")) return;
@@ -505,6 +717,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       );
 
       if (isGroupTarget && richFragment) {
+        if (info?.kind === "final") finalDeliverySeen = true;
         if (info?.kind !== "final") return;
         await sendOwnerAttention(
           resolvePayloadText(payload),
@@ -514,29 +727,33 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       }
 
       if (isGroupTarget && info?.kind === "final" && looksLikeApprovalFallbackText(text)) {
+        finalDeliverySeen = true;
         await sendOwnerAttention(text);
         return;
       }
 
       if (payload.isReasoning) {
-        if (isGroupTarget || outputVisibility !== "full") return;
-        appendBufferedText(text);
+        if (outputVisibility !== "full") return;
+        await emitFullSegment(text, urls);
         const trimmed = text.trim();
         if (trimmed) reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
         return;
       }
 
       if (info?.kind === "tool") {
-        if (!isGroupTarget && outputVisibility === "full") {
-          appendBufferedText(text);
-          appendBufferedUrls(urls);
+        if (isDefaultToolResultText(text)) return;
+        if (outputVisibility === "full") {
+          await emitFullRuntimeText("tool result", text, urls);
         }
         return;
       }
 
       if (info?.kind === "block") {
-        if (!isGroupTarget && outputVisibility === "normal") appendBufferedUrls(urls);
-        if (!isGroupTarget && outputVisibility === "full") {
+        if (outputVisibility === "full") {
+          await emitFullSegment(text, urls);
+        } else if (splitNormalBlockOutput) {
+          await emitFullSegment(text, urls);
+        } else if (outputVisibility === "minimal" || outputVisibility === "normal") {
           appendBufferedText(text);
           appendBufferedUrls(urls);
         }
@@ -544,6 +761,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       }
 
       if (info?.kind === "final") {
+        finalDeliverySeen = true;
         if (isClawChatNoopResponseText(text) && !richFragment && urls.length === 0) {
           log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
           openclawLlmContextDebug.writeSnapshot({
@@ -567,6 +785,14 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         }
         const finalText = richFragment && account.richInteractions ? mergeFinalText("") : mergeFinalText(text);
         const finalUrls = mergeFinalUrls(urls);
+        if (
+          isClawChatNoopResponseText(finalText) &&
+          !richFragment &&
+          finalUrls.length === 0
+        ) {
+          log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
+          return;
+        }
         const mediaFragments = await uploadMediaUrls(finalUrls);
         const result = await sendStatic(
           finalText,
@@ -585,17 +811,19 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       log?.error?.(
         `[${account.accountId}] clawchat-plugin-openclaw ${info.kind} reply failed: ${errorText}`,
       );
-      if (isGroupTarget) {
-        log?.error?.(
-          `[${account.accountId}] clawchat-plugin-openclaw group runtime failure suppressed from ClawChat clients group=${target.chatId}`,
-        );
-        return;
-      }
+      if (outputVisibility === "full") void emitFullRuntimeText("error", errorText);
     },
     onIdle: async () => {
       emitTyping(false);
       if (runDone) return;
       runDone = true;
+      if (finalDeliverySeen) return;
+      const fallbackText = bufferedOutputText.trim();
+      const fallbackUrls = bufferedOutputUrls.slice();
+      if (!fallbackText && fallbackUrls.length === 0) return;
+      const mediaFragments = await uploadMediaUrls(fallbackUrls);
+      const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
+      if (result?.messageId) recordThinkingIfLinked(result.messageId);
     },
     onCleanup: () => {
       emitTyping(false);
@@ -607,7 +835,69 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     replyOptions: {
       ...base.replyOptions,
       sourceReplyDeliveryMode: "automatic",
-      disableBlockStreaming: outputVisibility !== "full",
+      disableBlockStreaming: !splitNormalBlockOutput,
+      suppressDefaultToolProgressMessages: true,
+      allowProgressCallbacksWhenSourceDeliverySuppressed: splitFullOutput ? true : undefined,
+      onReasoningStream: splitFullOutput
+        ? async (payload: ReplyPayload) => {
+            if (consumeTerminalSend("reasoning")) return;
+            const text = resolvePayloadText(payload);
+            await emitFullRuntimeText("reasoning", text, resolveOutboundMediaUrls(payload).filter(Boolean));
+            const trimmed = text.trim();
+            if (trimmed) reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
+          }
+        : undefined,
+      onToolStart: splitFullOutput
+        ? async (payload) => {
+            if (consumeTerminalSend("tool-start")) return;
+            await emitFullSegment(formatToolStartSummary(payload));
+          }
+        : undefined,
+      onToolResult: splitFullOutput
+        ? async (payload: ReplyPayload) => {
+            if (consumeTerminalSend("tool-result")) return;
+            const text = resolvePayloadText(payload);
+            if (isDefaultToolResultText(text)) return;
+            await emitFullRuntimeText("tool result", text, resolveOutboundMediaUrls(payload).filter(Boolean));
+          }
+        : undefined,
+      onItemEvent: splitFullOutput
+        ? async (payload: Record<string, unknown>) => {
+            if (consumeTerminalSend("item-event")) return;
+            if (isToolProgressItem(payload)) return;
+            await emitFullRuntimeText("progress", summarizeProgressPayload(payload));
+          }
+        : undefined,
+      onPlanUpdate: splitFullOutput
+        ? async (payload: Record<string, unknown>) => {
+            if (consumeTerminalSend("plan-update")) return;
+            await emitFullRuntimeText("plan", summarizeProgressPayload(payload));
+          }
+        : undefined,
+      onCommandOutput: splitFullOutput
+        ? async (payload: Record<string, unknown>) => {
+            if (consumeTerminalSend("command-output")) return;
+            await emitFullSegment(formatCommandOutputSummary(payload));
+          }
+        : undefined,
+      onPatchSummary: splitFullOutput
+        ? async (payload: Record<string, unknown>) => {
+            if (consumeTerminalSend("patch-summary")) return;
+            await emitFullSegment(formatPatchSummary(payload));
+          }
+        : undefined,
+      onCompactionStart: splitFullOutput
+        ? async () => {
+            if (consumeTerminalSend("compaction-start")) return;
+            await emitFullSegment("[compaction] started");
+          }
+        : undefined,
+      onCompactionEnd: splitFullOutput
+        ? async () => {
+            if (consumeTerminalSend("compaction-end")) return;
+            await emitFullSegment("[compaction] finished");
+          }
+        : undefined,
     },
     markDispatchIdle: base.markDispatchIdle,
   };