@kafca/agentdock 0.1.24 → 0.1.26

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpTurnCoordinator = void 0;
 const desktop_js_1 = require("../../../../shared/desktop.js");
+const local_core_acp_progress_js_1 = require("./local-core-acp-progress.js");
+const local_core_acp_permission_lifecycle_js_1 = require("./local-core-acp-permission-lifecycle.js");
 const workspace_acp_permissions_js_1 = require("./workspace-acp-permissions.js");
+const local_core_slash_commands_js_1 = require("./local-core-slash-commands.js");
 class LocalCoreAcpTurnCoordinator {
     options;
     constructor(options) {
@@ -14,7 +17,7 @@ class LocalCoreAcpTurnCoordinator {
         if (!currentTurn || !currentRunId) {
             return;
         }
-        const pending = this.getToolCallsInOrder(currentTurn)
+        const pending = (0, local_core_acp_progress_js_1.getToolCallsInOrder)(currentTurn)
             .filter((toolCall) => !toolCall.emitted);
         if (pending.length === 0) {
             const title = currentTurn.pendingToolCallTitle?.trim();
@@ -25,14 +28,26 @@ class LocalCoreAcpTurnCoordinator {
             currentTurn.pendingToolCallTitle = undefined;
             currentTurn.pendingToolCallId = undefined;
             currentTurn.pendingToolCallDetail = undefined;
-            this.emitProgress(session, currentRunId, `🔧 ${title}`, messageId);
+            this.emitProgress(session, currentRunId, `🔧 ${title}`, messageId, createToolCallPayload({
+                id: currentTurn.activeToolCallKey,
+                name: title,
+                status: 'running',
+                content: '',
+            }));
             return;
         }
         for (const toolCall of pending) {
             toolCall.emitted = true;
-            this.emitProgress(session, currentRunId, `🔧 ${toolCall.title}`, toolCall.messageId);
+            this.emitProgress(session, currentRunId, `🔧 ${toolCall.title}`, toolCall.messageId, createToolCallPayload({
+                id: toolCall.key,
+                name: toolCall.title,
+                status: 'running',
+                input: toolCall.input,
+                detail: toolCall.detail,
+                content: '',
+            }));
         }
-        this.syncLegacyPendingToolCall(currentTurn, this.resolveFallbackToolCall(currentTurn));
+        (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
     }
     getPendingPermissionRequest(session, detail) {
         const runId = session?.currentRunId;
@@ -80,22 +95,29 @@ class LocalCoreAcpTurnCoordinator {
             });
             return;
         }
-        const options = Array.isArray(payload.params?.options)
-            ? payload.params.options
-                .map((option) => ({
-                optionId: String(option?.optionId || '').trim(),
-                name: String(option?.name || option?.optionId || '').trim(),
-                kind: String(option?.kind || '').trim(),
-                normalizedAction: (0, workspace_acp_permissions_js_1.normalizePermissionOptionAction)({
-                    optionId: option?.optionId,
-                    name: option?.name,
-                    kind: option?.kind,
-                }),
-            }))
-                .filter((option) => option.optionId)
-            : [];
+        const options = (0, local_core_acp_permission_lifecycle_js_1.parsePermissionOptions)(payload.params?.options);
         const toolTitle = (0, workspace_acp_permissions_js_1.formatToolCallContent)(payload.params?.toolCall);
-        const isSchedulerAdd = isSchedulerAddCommand(toolTitle);
+        if ((this.options.getThreadAgentMode?.(session.threadId) || local_core_slash_commands_js_1.DEFAULT_AGENT_MODE) === 'bypassPermissions') {
+            const selected = options.find((option) => option.normalizedAction === 'allow all')
+                || options.find((option) => option.normalizedAction === 'allow')
+                || options.find((option) => option.normalizedAction !== 'deny');
+            this.options.sendRaw(session, {
+                jsonrpc: '2.0',
+                id: payload.id,
+                result: {
+                    outcome: selected
+                        ? {
+                            outcome: 'selected',
+                            optionId: selected.optionId,
+                        }
+                        : {
+                            outcome: 'cancelled',
+                        },
+                },
+            });
+            return;
+        }
+        const isSchedulerAdd = (0, local_core_acp_permission_lifecycle_js_1.isSchedulerAddCommand)(toolTitle);
         if (isSchedulerAdd && session.schedulerJobCreatedByRun.get(currentRunId)) {
             this.options.sendRaw(session, {
                 jsonrpc: '2.0',
@@ -117,45 +139,27 @@ class LocalCoreAcpTurnCoordinator {
             return;
         }
         const buttonRows = (0, workspace_acp_permissions_js_1.toPermissionButtonRows)(options, desktop_js_1.normalizeDesktopBridgeButtonOption);
-        const permissionRequest = {
+        const approvalId = this.options.createApprovalRequest?.((0, local_core_acp_permission_lifecycle_js_1.createPermissionApprovalInput)({
+            threadId: session.threadId,
+            runId: currentRunId,
+            toolTitle,
+            options,
+        }));
+        const permissionRequest = (0, local_core_acp_permission_lifecycle_js_1.createRunningPermissionRequest)({
             requestId: payload.id,
             toolTitle,
-            isSchedulerAdd,
             options,
-        };
-        const approvalId = this.options.createApprovalRequest?.({
-            threadId: session.threadId,
+            approvalId,
+        });
+        (0, local_core_acp_permission_lifecycle_js_1.applyPendingPermissionRequest)({
+            session,
             runId: currentRunId,
-            title: toolTitle ? `Approve ${toolTitle}` : 'Approve agent action',
-            description: toolTitle || 'Agent requested permission before continuing.',
-            command: toolTitle,
-            options,
+            permissionRequest,
+            resolveFallbackToolCall: local_core_acp_progress_js_1.resolveFallbackToolCall,
+            syncLegacyPendingToolCall: local_core_acp_progress_js_1.syncLegacyPendingToolCall,
         });
-        if (approvalId) {
-            permissionRequest.approvalId = approvalId;
-        }
-        session.pendingPermissionByRun.set(currentRunId, permissionRequest);
-        if (session.currentTurn) {
-            session.currentTurn.permission = permissionRequest;
-            if (toolTitle && toolTitle !== 'Permission required before continuing.') {
-                session.currentTurn.pendingToolCallDetail = toolTitle;
-                const toolCall = this.resolveFallbackToolCall(session.currentTurn);
-                if (toolCall) {
-                    toolCall.detail = toolTitle;
-                    this.syncLegacyPendingToolCall(session.currentTurn, toolCall);
-                }
-            }
-        }
         this.options.updateRunStatus(currentRunId, session.threadId, 'awaiting_input');
-        const permissionPrompt = [
-            '等待工具确认',
-            '',
-            toolTitle,
-            '',
-            '请选择一个选项继续执行。',
-            '',
-            '若按钮没有显示，请直接回复：allow all / allow / deny',
-        ].join('\n');
+        const permissionPrompt = (0, local_core_acp_permission_lifecycle_js_1.createPermissionPrompt)(toolTitle);
         this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress');
         this.options.emitBridge({
             type: 'buttons',
@@ -181,24 +185,16 @@ class LocalCoreAcpTurnCoordinator {
                 if (update.content?.type !== 'text') {
                     return;
                 }
-                currentTurn.assistantText += String(update.content.text || '');
-                if (!currentTurn.previewStarted) {
-                    currentTurn.previewStarted = true;
-                    this.options.emitBridge({
-                        type: 'preview_start',
-                        sessionKey: session.bridgeSessionKey,
-                        replyCtx: currentRunId,
-                        previewHandle: currentTurn.previewHandle,
-                        content: currentTurn.assistantText,
-                    });
+                const projection = (0, local_core_acp_progress_js_1.applyAssistantMessageChunk)(currentTurn, String(update.content.text || ''));
+                if (!projection) {
                     return;
                 }
                 this.options.emitBridge({
-                    type: 'update_message',
+                    type: projection.bridgeType,
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
-                    previewHandle: currentTurn.previewHandle,
-                    content: currentTurn.assistantText,
+                    previewHandle: projection.previewHandle,
+                    content: projection.content,
                 });
                 return;
             }
@@ -207,92 +203,64 @@ class LocalCoreAcpTurnCoordinator {
                 if (update.content?.type !== 'text') {
                     return;
                 }
-                const thoughtChunk = String(update.content.text || '');
-                if (!thoughtChunk) {
+                const projection = (0, local_core_acp_progress_js_1.applyThoughtChunk)(currentTurn, String(update.content.text || ''));
+                if (!projection) {
                     return;
                 }
-                currentTurn.thoughtText += thoughtChunk;
-                const content = `💭 ${currentTurn.thoughtText.trim()}`;
                 if (this.options.upsertMessage) {
-                    this.options.upsertMessage(session.threadId, currentTurn.thoughtMessageId, 'assistant', content, 'progress');
-                }
-                if (!currentTurn.thoughtPreviewStarted) {
-                    currentTurn.thoughtPreviewStarted = true;
-                    this.options.emitBridge({
-                        type: 'preview_start',
-                        sessionKey: session.bridgeSessionKey,
-                        replyCtx: currentRunId,
-                        previewHandle: currentTurn.thoughtPreviewHandle,
-                        content,
-                    });
-                    return;
+                    this.options.upsertMessage(session.threadId, projection.messageId, 'assistant', projection.content, 'progress');
                 }
                 this.options.emitBridge({
-                    type: 'update_message',
+                    type: projection.bridgeType,
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
-                    previewHandle: currentTurn.thoughtPreviewHandle,
-                    content,
+                    previewHandle: projection.previewHandle,
+                    content: projection.content,
                 });
                 return;
             }
             case 'tool_call': {
-                const title = String(update.title || 'Running tool').trim();
-                const nextSequence = (currentTurn.toolCallSequence || 0) + 1;
-                currentTurn.toolCallSequence = nextSequence;
-                const key = this.extractToolCallKey(update) || `sequence:${nextSequence}`;
-                const toolCall = {
-                    key,
-                    title,
-                    messageId: `${currentRunId}-tool-${nextSequence}`,
-                    sequence: nextSequence,
-                    emitted: false,
-                };
-                currentTurn.pendingToolCalls = {
-                    ...(currentTurn.pendingToolCalls || {}),
-                    [key]: toolCall,
-                };
-                currentTurn.pendingToolCallOrder = [
-                    ...(currentTurn.pendingToolCallOrder || []).filter((item) => item !== key),
-                    key,
-                ];
-                currentTurn.activeToolCallKey = key;
-                this.syncLegacyPendingToolCall(currentTurn, toolCall);
+                const toolCall = (0, local_core_acp_progress_js_1.registerPendingToolCall)({ currentTurn, runId: currentRunId, update });
+                (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, toolCall);
                 return;
             }
             case 'tool_call_update': {
                 const title = String(update.title || 'Tool update').trim();
                 const status = String(update.status || '').trim();
-                const content = this.extractToolUpdateContent(update.content);
-                if (isSchedulerAddCommand(title) && /Created scheduler job\b/.test(content)) {
+                const content = (0, local_core_acp_progress_js_1.extractToolUpdateContent)(update.content);
+                if ((0, local_core_acp_permission_lifecycle_js_1.isSchedulerAddCommand)(title) && /Created scheduler job\b/.test(content)) {
                     session.schedulerJobCreatedByRun.set(currentRunId, true);
                 }
-                const toolCall = this.resolveToolCallForUpdate(currentTurn, update);
+                const toolCall = (0, local_core_acp_progress_js_1.resolveToolCallForUpdate)(currentTurn, update);
+                const updateInput = (0, local_core_acp_progress_js_1.extractToolCallInput)(update);
+                if (toolCall && updateInput !== undefined) {
+                    toolCall.input = updateInput;
+                }
                 const toolName = toolCall?.title.trim() || currentTurn.pendingToolCallTitle?.trim();
                 const messageId = toolCall?.messageId || currentTurn.pendingToolCallId;
                 const priorDetail = toolCall ? toolCall.detail?.trim() : currentTurn.pendingToolCallDetail?.trim();
-                if (this.isEmptyRunningToolUpdate(title, status, content)) {
+                if ((0, local_core_acp_progress_js_1.isEmptyRunningToolUpdate)({ title, status, content })) {
                     if (toolCall) {
-                        this.deleteToolCall(currentTurn, toolCall.key);
+                        (0, local_core_acp_progress_js_1.deletePendingToolCall)(currentTurn, toolCall.key);
                     }
                     else {
                         currentTurn.pendingToolCallTitle = undefined;
                         currentTurn.pendingToolCallId = undefined;
                         currentTurn.pendingToolCallDetail = undefined;
                     }
-                    this.syncLegacyPendingToolCall(currentTurn, this.resolveFallbackToolCall(currentTurn));
+                    (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
                     return;
                 }
-                const displayTitle = this.resolveToolUpdateDisplayTitle(title, status, priorDetail);
-                if (!this.isTerminalToolStatus(status) && displayTitle && !/^tool update$/i.test(displayTitle)) {
+                const displayTitle = (0, local_core_acp_progress_js_1.resolveToolUpdateDisplayTitle)({ title, status, priorDetail });
+                if (!(0, local_core_acp_progress_js_1.isTerminalToolStatus)(status) && displayTitle && !/^tool update$/i.test(displayTitle)) {
                     if (toolCall) {
                         toolCall.detail = displayTitle;
                     }
                     currentTurn.pendingToolCallDetail = displayTitle;
                 }
-                if (this.isTerminalToolStatus(status)) {
+                if ((0, local_core_acp_progress_js_1.isTerminalToolStatus)(status)) {
                     if (toolCall) {
-                        this.deleteToolCall(currentTurn, toolCall.key);
+                        (0, local_core_acp_progress_js_1.deletePendingToolCall)(currentTurn, toolCall.key);
                     }
                     else {
                         currentTurn.pendingToolCallTitle = undefined;
@@ -300,8 +268,16 @@ class LocalCoreAcpTurnCoordinator {
                         currentTurn.pendingToolCallDetail = undefined;
                     }
                 }
-                this.emitProgress(session, currentRunId, this.formatToolProgressMessage(toolName, displayTitle, status, content), messageId);
-                this.syncLegacyPendingToolCall(currentTurn, this.resolveFallbackToolCall(currentTurn));
+                const toolCallPayload = createToolCallPayload({
+                    id: toolCall?.key || currentTurn.activeToolCallKey,
+                    name: toolName || displayTitle || 'Tool update',
+                    status,
+                    input: updateInput === undefined ? toolCall?.input : updateInput,
+                    detail: displayTitle,
+                    content,
+                });
+                this.emitProgress(session, currentRunId, (0, local_core_acp_progress_js_1.formatToolProgressMessage)({ toolName, title: displayTitle, status, content }), messageId, toolCallPayload);
+                (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
                 return;
             }
             case 'plan': {
@@ -310,11 +286,10 @@ class LocalCoreAcpTurnCoordinator {
                 if (entries.length === 0) {
                     return;
                 }
-                const summary = entries
-                    .map((entry) => String(entry?.content || '').trim())
-                    .filter(Boolean)
-                    .join(' | ');
-                const content = `💭 ${summary}`;
+                const content = (0, local_core_acp_progress_js_1.formatPlanProgress)(entries);
+                if (!content) {
+                    return;
+                }
                 this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
                 this.options.emitBridge({
                     type: 'reply',
@@ -328,12 +303,12 @@ class LocalCoreAcpTurnCoordinator {
                 return;
         }
     }
-    emitProgress(session, currentRunId, content, messageId) {
+    emitProgress(session, currentRunId, content, messageId, toolCall) {
         if (messageId && this.options.upsertMessage) {
-            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress');
+            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall);
         }
         else {
-            this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+            this.options.appendMessage(session.threadId, 'assistant', content, 'progress', toolCall);
         }
         this.options.emitBridge({
             type: 'reply',
@@ -341,93 +316,20 @@ class LocalCoreAcpTurnCoordinator {
             replyCtx: currentRunId,
             messageId,
             content,
+            toolCall,
         });
     }
-    extractToolUpdateContent(content) {
-        return Array.isArray(content)
-            ? content
-                .map((entry) => entry?.type === 'content' && entry?.content?.type === 'text'
-                ? String(entry.content.text || '')
-                : '')
-                .filter(Boolean)
-                .join('\n')
-            : '';
-    }
-    formatToolProgressMessage(toolName, title, status, content) {
-        const detail = [title, status, content].filter(Boolean).join(' - ');
-        return toolName ? `🔧 ${toolName}: ${detail || 'Tool update'}` : `🔧 ${detail || 'Tool update'}`;
-    }
-    resolveToolUpdateDisplayTitle(title, status, priorDetail) {
-        if (priorDetail && (this.isTerminalToolStatus(status) || /^tool update$/i.test(title.trim()))) {
-            return priorDetail;
-        }
-        if (this.isTerminalToolStatus(status) && /^tool update$/i.test(title.trim())) {
-            return '';
-        }
-        return title;
-    }
-    isEmptyRunningToolUpdate(title, status, content) {
-        return !content.trim() &&
-            /^running$/i.test(status) &&
-            (!title.trim() || /^tool update$/i.test(title));
-    }
-    isTerminalToolStatus(status) {
-        return /^(completed|failed|error|cancelled|canceled)$/i.test(status.trim());
-    }
-    extractToolCallKey(update) {
-        for (const key of ['toolCallId', 'tool_call_id', 'callId', 'call_id', 'invocationId', 'invocation_id', 'id']) {
-            const value = update[key];
-            if (typeof value === 'string' || typeof value === 'number') {
-                const normalized = String(value).trim();
-                if (normalized) {
-                    return normalized;
-                }
-            }
-        }
-        return '';
-    }
-    resolveToolCallForUpdate(currentTurn, update) {
-        const explicitKey = this.extractToolCallKey(update);
-        if (explicitKey && currentTurn.pendingToolCalls?.[explicitKey]) {
-            currentTurn.activeToolCallKey = explicitKey;
-            return currentTurn.pendingToolCalls[explicitKey];
-        }
-        return this.resolveFallbackToolCall(currentTurn);
-    }
-    resolveFallbackToolCall(currentTurn) {
-        const active = currentTurn.activeToolCallKey
-            ? currentTurn.pendingToolCalls?.[currentTurn.activeToolCallKey]
-            : undefined;
-        if (active) {
-            return active;
-        }
-        const ordered = this.getToolCallsInOrder(currentTurn);
-        return ordered[ordered.length - 1];
-    }
-    getToolCallsInOrder(currentTurn) {
-        const toolCalls = currentTurn.pendingToolCalls || {};
-        const orderedKeys = currentTurn.pendingToolCallOrder || [];
-        return orderedKeys
-            .map((key) => toolCalls[key])
-            .filter((toolCall) => Boolean(toolCall));
-    }
-    deleteToolCall(currentTurn, key) {
-        if (currentTurn.pendingToolCalls) {
-            delete currentTurn.pendingToolCalls[key];
-        }
-        currentTurn.pendingToolCallOrder = (currentTurn.pendingToolCallOrder || []).filter((item) => item !== key);
-        if (currentTurn.activeToolCallKey === key) {
-            currentTurn.activeToolCallKey = undefined;
-        }
-    }
-    syncLegacyPendingToolCall(currentTurn, toolCall) {
-        currentTurn.pendingToolCallTitle = toolCall?.title;
-        currentTurn.pendingToolCallId = toolCall?.messageId;
-        currentTurn.pendingToolCallDetail = toolCall?.detail;
-        currentTurn.activeToolCallKey = toolCall?.key;
-    }
 }
 exports.LocalCoreAcpTurnCoordinator = LocalCoreAcpTurnCoordinator;
-function isSchedulerAddCommand(value) {
-    return /\blac\s+scheduler\s+add\b/.test(String(value || ''));
+function createToolCallPayload(input) {
+    const status = input.status.trim() || 'running';
+    return {
+        id: input.id,
+        name: input.name.trim() || 'Tool call',
+        status,
+        input: input.input,
+        output: input.content,
+        detail: input.detail?.trim() || undefined,
+        label: /^running$/i.test(status) ? '工具调用' : '工具结果',
+    };
 }

package/dist-electron/services/local-ai-core/src/acp/local-core-slash-commands.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AGENT_MODE = void 0;
+exports.parseSlashCommand = parseSlashCommand;
+exports.normalizeAgentMode = normalizeAgentMode;
+exports.formatAgentMode = formatAgentMode;
+exports.modeHelpText = modeHelpText;
+exports.DEFAULT_AGENT_MODE = 'default';
+const MODE_ALIASES = {
+    auto: 'auto',
+    default: 'default',
+    acceptedits: 'acceptEdits',
+    'accept-edits': 'acceptEdits',
+    accept_edits: 'acceptEdits',
+    dontask: 'dontAsk',
+    "don'task": 'dontAsk',
+    'dont-ask': 'dontAsk',
+    dont_ask: 'dontAsk',
+    plan: 'plan',
+    bypass: 'bypassPermissions',
+    bypasspermissions: 'bypassPermissions',
+    'bypass-permissions': 'bypassPermissions',
+    bypass_permissions: 'bypassPermissions',
+    yolo: 'bypassPermissions',
+};
+const MODE_LABELS = {
+    auto: 'auto',
+    default: 'default',
+    acceptEdits: 'acceptEdits',
+    dontAsk: 'dontAsk',
+    plan: 'plan',
+    bypassPermissions: 'yolo',
+};
+function parseSlashCommand(text) {
+    const normalized = String(text || '').trim();
+    if (!normalized.startsWith('/')) {
+        return null;
+    }
+    const [name = '', ...args] = normalized.slice(1).split(/\s+/);
+    const commandName = name.trim().toLowerCase();
+    if (!commandName) {
+        return null;
+    }
+    return { name: commandName, args };
+}
+function normalizeAgentMode(mode) {
+    const key = String(mode || '').trim().toLowerCase();
+    return MODE_ALIASES[key] || '';
+}
+function formatAgentMode(mode) {
+    const normalized = normalizeAgentMode(mode) || mode || exports.DEFAULT_AGENT_MODE;
+    return MODE_LABELS[normalized] || normalized;
+}
+function modeHelpText(currentMode) {
+    return [
+        `当前模式：${formatAgentMode(currentMode)}`,
+        '可用模式：default, auto, acceptEdits, dontAsk, plan, yolo。',
+        '`/mode yolo` 会跳过工具权限申请；使用 `/mode default` 可恢复默认权限。'
+    ].join('\n');
+}

package/dist-electron/services/local-ai-core/src/channel/lark/local-core-lark-gateway.js

@@ -47,6 +47,8 @@ const registration_js_1 = require("./registration.js");
 const runtime_state_js_1 = require("./runtime-state.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
+const LARK_FINAL_PATCH_INTERVAL_MS = 900;
+const LARK_PROGRESS_PATCH_INTERVAL_MS = 3000;
 class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     options;
     // Lark returns 200340 when card action events are not enabled in the app's
@@ -246,6 +248,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const file = await (0, file_utils_js_1.prepareChannelFile)({
             path: part.path,
             fileName: part.fileName,
+            workspacePath: typeof part.metadata?.workspacePath === 'string' ? part.metadata.workspacePath : undefined,
             maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
             platformLabel: 'Lark',
         });
@@ -468,35 +471,39 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     return;
                 }
                 this.consumeBridgeEvent(turn, event);
-                const rendered = (0, runtime_state_js_1.renderLarkBridgeEventMessage)(turn, event);
-                if (!rendered.text && rendered.buttonRows.length === 0) {
-                    this.options.log?.(`localcore-lark bridge event produced empty render for sessionKey=${sessionKey} type=${event.type}`);
-                    return;
-                }
-                const existingMessageId = (0, runtime_state_js_1.getLarkRenderedMessageId)(turn, rendered);
-                const shouldThrottle = event.type === 'update_message' &&
-                    rendered.isFinal &&
-                    existingMessageId &&
-                    Date.now() - (turn.lastPatchedAtByMessageId[existingMessageId] || 0) < 900;
-                this.options.log?.(`localcore-lark bridge event type=${event.type} sessionKey=${sessionKey} hasMessageId=${Boolean(existingMessageId)} throttle=${shouldThrottle}`);
-                if (shouldThrottle) {
-                    return;
-                }
-                if (!existingMessageId) {
-                    const createdId = await this.sendTextAsCard(state, route.chatId, rendered.text, rendered.buttonRows, sessionKey, binding.thread_id);
-                    if (createdId) {
-                        (0, runtime_state_js_1.setLarkRenderedMessageId)(turn, rendered, createdId);
-                        if (rendered.isFinal) {
-                            this.options.store.updatePlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId, createdId, routePlatformKey);
+                const renderedMessages = (0, runtime_state_js_1.renderLarkBridgeEventMessages)(turn, event);
+                for (const renderedMessage of renderedMessages) {
+                    if (!renderedMessage.text && renderedMessage.buttonRows.length === 0) {
+                        this.options.log?.(`localcore-lark bridge event produced empty render for sessionKey=${sessionKey} type=${event.type}`);
+                        continue;
+                    }
+                    const existingMessageId = (0, runtime_state_js_1.getLarkRenderedMessageId)(turn, renderedMessage);
+                    const shouldThrottle = event.type === 'update_message' &&
+                        existingMessageId &&
+                        Date.now() - (turn.lastPatchedAtByMessageId[existingMessageId] || 0) < (renderedMessage.isFinal ? LARK_FINAL_PATCH_INTERVAL_MS : LARK_PROGRESS_PATCH_INTERVAL_MS);
+                    this.options.log?.(`localcore-lark bridge event type=${event.type} sessionKey=${sessionKey} hasMessageId=${Boolean(existingMessageId)} throttle=${shouldThrottle}`);
+                    if (shouldThrottle) {
+                        continue;
+                    }
+                    if (existingMessageId && renderedMessage.updatePolicy === 'create-only') {
+                        continue;
+                    }
+                    if (!existingMessageId) {
+                        const createdId = await this.sendTextAsCard(state, route.chatId, renderedMessage.text, renderedMessage.buttonRows, sessionKey, binding.thread_id);
+                        if (createdId) {
+                            (0, runtime_state_js_1.setLarkRenderedMessageId)(turn, renderedMessage, createdId);
+                            if (renderedMessage.isFinal) {
+                                this.options.store.updatePlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId, createdId, routePlatformKey);
+                            }
+                            this.options.log?.(`localcore-lark sent new card message ${createdId} for sessionKey=${sessionKey}`);
                         }
-                        this.options.log?.(`localcore-lark sent new card message ${createdId} for sessionKey=${sessionKey}`);
+                        continue;
                     }
-                    return;
+                    await this.patchTextCard(state, existingMessageId, renderedMessage.text, renderedMessage.buttonRows, sessionKey, binding.thread_id);
+                    turn.lastPatchedAt = Date.now();
+                    turn.lastPatchedAtByMessageId[existingMessageId] = turn.lastPatchedAt;
+                    this.options.log?.(`localcore-lark patched card message ${existingMessageId} for sessionKey=${sessionKey}`);
                 }
-                await this.patchTextCard(state, existingMessageId, rendered.text, rendered.buttonRows, sessionKey, binding.thread_id);
-                turn.lastPatchedAt = Date.now();
-                turn.lastPatchedAtByMessageId[existingMessageId] = turn.lastPatchedAt;
-                this.options.log?.(`localcore-lark patched card message ${existingMessageId} for sessionKey=${sessionKey}`);
             }
             catch (error) {
                 this.options.log?.(`localcore-lark bridge send failed for sessionKey=${sessionKey}: ${error instanceof Error ? error.message : String(error)}`);
@@ -620,6 +627,10 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         if (slashCommand?.name === 'new') {
             const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`;
             const nextThread = await router.createThread(input.workspaceId, title);
+            const inheritedMode = this.options.store.getThreadRow?.(threadId)?.agent_mode || '';
+            if (inheritedMode && inheritedMode !== 'default') {
+                this.options.store.updateThreadAgentMode?.(nextThread.id, inheritedMode);
+            }
             const now = new Date().toISOString();
             this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
             this.options.store.upsertPlatformThreadBinding({
@@ -650,7 +661,9 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return { paired: true, threadId };
         }
         this.options.store.clearPlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId);
-        const wrappedText = (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
+        const wrappedText = slashCommand
+            ? input.text
+            : (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
         await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
@@ -1095,6 +1108,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         return this.larkModulePromise;
     }
     async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
+        const startedAt = Date.now();
         const response = await state.client.im.message.create({
             params: {
                 receive_id_type: this.resolveReceiveIdType(chatId),
@@ -1105,6 +1119,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
             },
         });
+        this.options.log?.(`localcore-lark card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
         return String(response?.data?.message_id || '').trim();
     }
     resolveReceiveIdType(receiveId) {
@@ -1135,6 +1150,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
     }
     async patchTextCard(state, messageId, text, buttonRows = [], sessionKey, threadId) {
+        const startedAt = Date.now();
         await state.client.im.message.patch({
             path: {
                 message_id: messageId,
@@ -1143,6 +1159,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
             },
         });
+        this.options.log?.(`localcore-lark card patch took ${Date.now() - startedAt}ms message=${messageId} textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
     }
     generatePairingCode() {
         return String((0, node_crypto_1.randomInt)(100000, 1000000));