@clawling/clawchat-plugin-openclaw 2026.5.12-31 → 2026.5.12-38

package/dist/src/api-client.js

@@ -249,7 +249,7 @@ export function createOpenclawClawlingApiClient(opts) {
                 headers: { "content-type": "application/json" },
             });
         },
-        async agentsConnect({ code: inviteCode, platform, type }) {
+        async agentsConnect({ code: inviteCode, platform, type, user_id: userId }) {
             if (!inviteCode?.trim()) {
                 throw new ClawlingApiError("validation", "agentsConnect: inviteCode is required");
             }
@@ -259,14 +259,18 @@ export function createOpenclawClawlingApiClient(opts) {
             if (!type?.trim()) {
                 throw new ClawlingApiError("validation", "agentsConnect: type is required");
             }
+            const body = {
+                code: inviteCode.trim(),
+                platform: platform.trim(),
+                type: type.trim(),
+            };
+            if (userId?.trim()) {
+                body.user_id = userId.trim();
+            }
             return await call("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) {

package/dist/src/client.js

@@ -1,9 +1,17 @@
+import { createHash } from "node:crypto";
+import os from "node:os";
 import { createClawChatClient } from "./ws-client.js";
+import { CHANNEL_ID } from "./config.js";
+export function resolveOpenclawClawlingDeviceId(account) {
+    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, overrides = {}) {
     const client = createClawChatClient({
         url: account.websocketUrl,
         token: account.token,
-        deviceId: account.userId,
+        deviceId: resolveOpenclawClawlingDeviceId(account),
         ...(overrides.transport ? { transport: overrides.transport } : {}),
         reconnect: {
             enabled: true,

package/dist/src/commands.js

@@ -64,18 +64,16 @@ function persistOutputVisibility(draft, chatId, outputVisibility) {
     });
 }
 function formatOutputVisibilityResult(outputVisibility) {
-    const runtimeStatus = outputVisibility === "full" ? "on" : "off";
     const detailLevel = {
-        minimal: "quiet",
-        normal: "normal",
-        full: "verbose",
+        minimal: "final only",
+        normal: "final plus block output",
+        full: "final plus buffered reasoning, tool/progress, and block output",
     };
     return [
         "**ClawChat output updated**",
         "",
         `- visibility: \`${outputVisibility}\``,
-        `- runtime status: \`${runtimeStatus}\``,
-        `- detail level: \`${detailLevel[outputVisibility]}\``,
+        `- output: \`${detailLevel[outputVisibility]}\``,
         "",
         "Applies to new ClawChat messages.",
     ].join("\n");

package/dist/src/config.js

@@ -191,6 +191,29 @@ function readGroupMode(value) {
 function readGroupCommandMode(value) {
     return value === "all" || value === "off" ? value : "owner";
 }
+function readOutputVisibility(value) {
+    return value === "minimal" || value === "full" ? value : "normal";
+}
+function readOptionalOutputVisibility(value) {
+    return value === "minimal" || value === "normal" || value === "full" ? value : undefined;
+}
+function readChats(value) {
+    const rawChats = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const chats = {};
+    for (const [chatId, rawChat] of Object.entries(rawChats)) {
+        if (!chatId)
+            continue;
+        const chat = rawChat && typeof rawChat === "object" && !Array.isArray(rawChat)
+            ? rawChat
+            : {};
+        const outputVisibility = readOptionalOutputVisibility(chat.outputVisibility);
+        if (outputVisibility)
+            chats[chatId] = { outputVisibility };
+    }
+    return chats;
+}
 function readGroups(value) {
     const rawGroups = value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -202,9 +225,11 @@ function readGroups(value) {
         const group = rawGroup && typeof rawGroup === "object" && !Array.isArray(rawGroup)
             ? rawGroup
             : {};
+        const outputVisibility = readOptionalOutputVisibility(group.outputVisibility);
         groups[chatId] = {
             groupMode: readGroupMode(group.groupMode),
             groupCommandMode: readGroupCommandMode(group.groupCommandMode),
+            ...(outputVisibility ? { outputVisibility } : {}),
         };
     }
     return groups;
@@ -219,6 +244,13 @@ export function effectiveGroupCommandMode(account, chatId) {
         ?? account.groups["*"]?.groupCommandMode
         ?? account.groupCommandMode;
 }
+export function effectiveOutputVisibility(account, chatId, chatType) {
+    return account.chats?.[chatId]?.outputVisibility
+        ?? (chatType === "group" ? account.groups?.[chatId]?.outputVisibility : undefined)
+        ?? (chatType === "group" ? account.groups?.["*"]?.outputVisibility : undefined)
+        ?? account.outputVisibility
+        ?? "normal";
+}
 function readReconnect(raw) {
     const s = raw && typeof raw === "object" ? raw : {};
     return {
@@ -261,6 +293,8 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
     const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
     const ownerUserId = readOptionalString(channel.ownerUserId) || readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV);
     const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
+    const outputVisibility = readOutputVisibility(channel.outputVisibility);
+    const chats = readChats(channel.chats);
     const groupMode = readGroupMode(channel.groupMode);
     const groupCommandMode = readGroupCommandMode(channel.groupCommandMode);
     const groups = readGroups(channel.groups);
@@ -284,6 +318,8 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         agentId,
         userId,
         ownerUserId,
+        outputVisibility,
+        chats,
         groupMode,
         groupCommandMode,
         groups,

package/dist/src/login.runtime.js

@@ -139,10 +139,12 @@ export async function runOpenclawClawlingLogin(params) {
     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) {

package/dist/src/reply-dispatcher.js

@@ -1,6 +1,7 @@
 import { interactiveReplyToPresentation, renderMessagePresentationFallbackText, } from "openclaw/plugin-sdk/interactive-runtime";
 import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
+import { effectiveOutputVisibility, } from "./config.js";
 import { uploadOutboundMedia } from "./media-runtime.js";
 import { sendOpenclawClawlingText, } from "./outbound.js";
 import { isClawChatNoopResponseText } from "./profile-prompt.js";
@@ -103,18 +104,162 @@ function resolvePayloadText(payload) {
         return payload.text ?? "";
     return renderMessagePresentationFallbackText({ presentation, text: payload.text ?? null });
 }
+const FULL_OUTPUT_SUMMARY_MAX = 600;
+function truncateSummary(text) {
+    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) {
+    if (value == null)
+        return "";
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return "";
+        try {
+            const parsed = JSON.parse(trimmed);
+            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).slice(0, 6);
+        return keys.length ? `object with ${keys.join(", ")}` : "object";
+    }
+    return truncateSummary(String(value));
+}
+function readStringField(payload, field) {
+    const value = payload[field];
+    return typeof value === "string" ? value.trim() : "";
+}
+function readPayloadCommand(payload) {
+    const args = payload.args;
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return "";
+    const command = args.command;
+    return typeof command === "string" ? command.trim() : "";
+}
+function normalizeCommandLabel(value) {
+    const trimmed = value.trim();
+    return trimmed.replace(/^command\s+/i, "").trim() || trimmed;
+}
+function isTerminalCommandOutput(payload) {
+    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) {
+    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) {
+    return /^[🛠🔧]/u.test(text.trim());
+}
+function summarizeProgressPayload(payload) {
+    return (readStringField(payload, "progressText") ||
+        readStringField(payload, "summary") ||
+        readStringField(payload, "message") ||
+        readStringField(payload, "title") ||
+        readStringField(payload, "name") ||
+        readStringField(payload, "status") ||
+        summarizeValue(payload));
+}
+function formatToolStartSummary(payload) {
+    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) {
+    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) {
+    const summary = readStringField(payload, "summary");
+    if (summary)
+        return `[patch] ${truncateSummary(summary)}`;
+    const parts = [];
+    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) {
+    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) {
+    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) {
+    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.
  *
- * The plugin intentionally forces complete-message delivery. It sets
- * `disableBlockStreaming: true` in reply options so OpenClaw does not split
- * deliver blocks for this channel. If the host still delivers non-final
- * blocks, the dispatcher buffers or ignores them and only emits materialized
- * `message.send` / `message.reply` frames for the final reply.
+ * ClawChat emits only materialized `message.send` / `message.reply` frames for
+ * 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) {
     const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, store, log, } = options;
     const isGroupTarget = target.chatType === "group";
+    const outputVisibility = effectiveOutputVisibility(account, target.chatId, target.chatType);
+    const splitFullOutput = outputVisibility === "full" && !isGroupTarget;
     const ownerDirectTarget = () => {
         const ownerUserId = account.ownerUserId?.trim();
         return ownerUserId ? { chatId: ownerUserId, chatType: "direct" } : null;
@@ -142,9 +287,14 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     }
     // ----- Reply state ------------------------------------------------------
     let reasoningText = "";
+    let bufferedOutputText = "";
+    const bufferedOutputLineSet = new Set();
+    const emittedFullSegmentSet = new Set();
+    const bufferedOutputUrls = [];
     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 });
     const terminalSendScopeId = options.terminalSendScopeId ?? null;
@@ -229,6 +379,42 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         recordOutbound("thinking", messageId, thinkingText);
         reasoningText = "";
     };
+    const appendBufferedText = (value) => {
+        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) => {
+        for (const url of urls) {
+            if (url && !bufferedOutputUrls.includes(url))
+                bufferedOutputUrls.push(url);
+        }
+    };
+    const fullSegmentKey = (text, urls) => JSON.stringify({
+        text: text.replace(/\s+/g, " ").trim(),
+        urls: urls.filter(Boolean),
+    });
+    const mergeFinalText = (text) => {
+        if (outputVisibility === "minimal" || outputVisibility === "full")
+            return text;
+        return [bufferedOutputText.trim(), text.trim()].filter(Boolean).join("\n");
+    };
+    const mergeFinalUrls = (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);
+        }
+        return merged;
+    };
     const mintStaticMessageId = () => `${account.userId}-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const emitTyping = (isTyping) => {
         if (!isTyping && !typingActive)
@@ -336,13 +522,38 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         });
         return result;
     };
+    const emitFullSegment = async (text, urls = []) => {
+        if (outputVisibility !== "full") {
+            appendBufferedText(text);
+            appendBufferedUrls(urls);
+            return;
+        }
+        if (!splitFullOutput) {
+            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, text, urls = []) => {
+        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 = "";
-            runDone = false;
         },
         deliver: async (payload, info) => {
             if (consumeTerminalSend(info?.kind ?? "unknown"))
@@ -352,24 +563,47 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
             log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw deliver kind=${info?.kind ?? "unknown"} text_len=${text.length} media_urls=${urls.length} reasoning=${payload.isReasoning === true}`);
             if (isGroupTarget && richFragment) {
+                if (info?.kind === "final")
+                    finalDeliverySeen = true;
                 if (info?.kind !== "final")
                     return;
                 await sendOwnerAttention(resolvePayloadText(payload), richFragment);
                 return;
             }
             if (isGroupTarget && info?.kind === "final" && looksLikeApprovalFallbackText(text)) {
+                finalDeliverySeen = true;
                 await sendOwnerAttention(text);
                 return;
             }
             if (payload.isReasoning) {
-                if (isGroupTarget || !account.forwardThinking)
+                if (outputVisibility !== "full")
                     return;
-                reasoningText = text;
+                await emitFullSegment(text, urls);
+                const trimmed = text.trim();
+                if (trimmed)
+                    reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
                 return;
             }
-            if (info?.kind === "tool")
+            if (info?.kind === "tool") {
+                if (isDefaultToolResultText(text))
+                    return;
+                if (outputVisibility === "full") {
+                    await emitFullRuntimeText("tool result", text, urls);
+                }
                 return;
+            }
+            if (info?.kind === "block") {
+                if (outputVisibility === "full") {
+                    await emitFullSegment(text, urls);
+                }
+                else if (outputVisibility === "minimal" || outputVisibility === "normal") {
+                    appendBufferedText(text);
+                    appendBufferedUrls(urls);
+                }
+                return;
+            }
             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({
@@ -391,19 +625,21 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     });
                     return;
                 }
-                const mediaFragments = await uploadMediaUrls(urls);
-                const result = await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
+                const finalText = richFragment && account.richInteractions ? mergeFinalText("") : mergeFinalText(text);
+                const finalUrls = mergeFinalUrls(urls);
+                const mediaFragments = await uploadMediaUrls(finalUrls);
+                const result = await sendStatic(finalText, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
                 if (result?.messageId)
                     recordThinkingIfLinked(result.messageId);
                 return;
             }
-            // kind === "block" or unknown: OpenClaw may still call this path while
-            // the model is producing output. ClawChat gets only the final materialized
-            // reply.
+            // Unknown delivery kind: keep ClawChat output tied to OpenClaw final.
         },
         onError: (error, info) => {
             const errorText = normalizeReplyErrorText(error);
             log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw ${info.kind} reply failed: ${errorText}`);
+            if (!isGroupTarget && outputVisibility === "full")
+                void emitFullRuntimeText("error", errorText);
             if (isGroupTarget) {
                 log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw group runtime failure suppressed from ClawChat clients group=${target.chatId}`);
                 return;
@@ -414,6 +650,16 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             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);
@@ -425,6 +671,80 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             ...base.replyOptions,
             sourceReplyDeliveryMode: "automatic",
             disableBlockStreaming: true,
+            suppressDefaultToolProgressMessages: true,
+            allowProgressCallbacksWhenSourceDeliverySuppressed: outputVisibility === "full" ? true : undefined,
+            onReasoningStream: outputVisibility === "full"
+                ? async (payload) => {
+                    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: outputVisibility === "full"
+                ? async (payload) => {
+                    if (consumeTerminalSend("tool-start"))
+                        return;
+                    await emitFullSegment(formatToolStartSummary(payload));
+                }
+                : undefined,
+            onToolResult: outputVisibility === "full"
+                ? async (payload) => {
+                    if (consumeTerminalSend("tool-result"))
+                        return;
+                    const text = resolvePayloadText(payload);
+                    if (isDefaultToolResultText(text))
+                        return;
+                    await emitFullRuntimeText("tool result", text, resolveOutboundMediaUrls(payload).filter(Boolean));
+                }
+                : undefined,
+            onItemEvent: outputVisibility === "full"
+                ? async (payload) => {
+                    if (consumeTerminalSend("item-event"))
+                        return;
+                    if (isToolProgressItem(payload))
+                        return;
+                    await emitFullRuntimeText("progress", summarizeProgressPayload(payload));
+                }
+                : undefined,
+            onPlanUpdate: outputVisibility === "full"
+                ? async (payload) => {
+                    if (consumeTerminalSend("plan-update"))
+                        return;
+                    await emitFullRuntimeText("plan", summarizeProgressPayload(payload));
+                }
+                : undefined,
+            onCommandOutput: outputVisibility === "full"
+                ? async (payload) => {
+                    if (consumeTerminalSend("command-output"))
+                        return;
+                    await emitFullSegment(formatCommandOutputSummary(payload));
+                }
+                : undefined,
+            onPatchSummary: outputVisibility === "full"
+                ? async (payload) => {
+                    if (consumeTerminalSend("patch-summary"))
+                        return;
+                    await emitFullSegment(formatPatchSummary(payload));
+                }
+                : undefined,
+            onCompactionStart: outputVisibility === "full"
+                ? async () => {
+                    if (consumeTerminalSend("compaction-start"))
+                        return;
+                    await emitFullSegment("[compaction] started");
+                }
+                : undefined,
+            onCompactionEnd: outputVisibility === "full"
+                ? async () => {
+                    if (consumeTerminalSend("compaction-end"))
+                        return;
+                    await emitFullSegment("[compaction] finished");
+                }
+                : undefined,
         },
         markDispatchIdle: base.markDispatchIdle,
     };