@kafca/agentdock 0.1.28 → 0.1.29

package/dist-electron/electron/workspace-task-store.test.js

@@ -11,6 +11,8 @@ const node_os_1 = require("node:os");
 const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-store.js");
 const local_core_acp_session_coordinator_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-session-coordinator.js");
 const scheduler_service_js_1 = require("../services/local-ai-core/src/scheduler/scheduler-service.js");
+const bootstrap_js_1 = require("../services/local-ai-core/src/kernel/bootstrap.js");
+const local_core_controller_js_1 = require("../services/local-ai-core/src/runtime/local-core-controller.js");
 (0, node_test_1.default)('workspace registry entries persist in LocalCoreAcpStore', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-registry-'));
     try {
@@ -36,6 +38,50 @@ const scheduler_service_js_1 = require("../services/local-ai-core/src/scheduler/
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('scheduler create resolves a Lark route from the current thread binding', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-binding-route-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        const thread = runtime.store.createThread('workspace-a', 'Lark thread');
+        const now = new Date().toISOString();
+        runtime.store.upsertPlatformThreadBinding({
+            workspace_id: 'workspace-a',
+            platform: 'lark',
+            chat_id: 'chat-1',
+            platform_user_id: 'user-1',
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const job = await controller.createScheduledJob({
+            workspaceId: 'workspace-a',
+            threadId: thread.id,
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'bound lark task',
+            enabled: true,
+        });
+        strict_1.default.equal(job.platform, 'lark');
+        strict_1.default.deepEqual(job.route, {
+            type: 'channel.chat',
+            channelId: 'chat-1',
+            participantId: 'user-1',
+            threadId: thread.id,
+        });
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('ACP runtime env includes the current workspace path for file returns', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-env-'));
     try {
@@ -92,6 +138,72 @@ const scheduler_service_js_1 = require("../services/local-ai-core/src/scheduler/
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP scheduled session can override permission mode without changing thread mode', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-permission-mode-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const thread = store.createThread('workspace-a', 'Thread');
+        const capturedSessionNewParams = [];
+        let closeCount = 0;
+        const coordinator = new local_core_acp_session_coordinator_js_1.LocalCoreAcpSessionCoordinator({
+            store,
+            transport: {
+                spawnSession(input) {
+                    return {
+                        threadId: input.threadId,
+                        bridgeSessionKey: input.bridgeSessionKey,
+                        closed: false,
+                        sessionId: '',
+                        supportsLoad: false,
+                        pendingPermissionByRun: new Map(),
+                        schedulerJobCreatedByRun: new Map(),
+                        launchPermissionMode: '',
+                    };
+                },
+                initializeSession: async () => { },
+                request: async (_session, method, params) => {
+                    if (method === 'session/new') {
+                        capturedSessionNewParams.push(params);
+                        return { sessionId: 'session-1' };
+                    }
+                    return {};
+                },
+                closeSession: () => {
+                    closeCount += 1;
+                },
+                closeSessionWithError: () => { },
+                sendRaw: () => true,
+            },
+            runThreadMap: new Map(),
+            emitBridge: () => { },
+        });
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'claudecode',
+            command: 'claude',
+            args: [],
+            env: {},
+            workDir: '/tmp/workspace-a',
+            model: '',
+        }, { permissionMode: 'bypassPermissions' });
+        strict_1.default.equal(capturedSessionNewParams[0]?._meta?.claudeCode?.options?.permissionMode, 'bypassPermissions');
+        strict_1.default.equal(store.getThreadRow(thread.id)?.agent_mode, 'default');
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'claudecode',
+            command: 'claude',
+            args: [],
+            env: {},
+            workDir: '/tmp/workspace-a',
+            model: '',
+        });
+        strict_1.default.equal(closeCount, 1);
+        strict_1.default.equal(capturedSessionNewParams[1]?._meta, undefined);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('scheduler uses short ids for new jobs and resolves legacy full ids by short id', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-id-store-'));
     try {

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

@@ -27,11 +27,11 @@ class LocalCoreAcpBackend {
         });
         this.turnCoordinator = new local_core_acp_turn_coordinator_js_1.LocalCoreAcpTurnCoordinator({
             emitBridge: (event) => this.emitBridgeEvent(event),
-            appendMessage: (threadId, role, content, kind, toolCall) => {
-                this.options.store.appendMessage(threadId, role, content, kind, toolCall);
+            appendMessage: (threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus) => {
+                this.options.store.appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus);
             },
-            upsertMessage: (threadId, id, role, content, kind, toolCall) => {
-                this.options.store.upsertMessage(threadId, id, role, content, kind, toolCall);
+            upsertMessage: (threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus) => {
+                this.options.store.upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus);
             },
             updateRunStatus: (runId, threadId, status) => {
                 this.options.store.updateRun(runId, threadId, status);
@@ -129,7 +129,7 @@ class LocalCoreAcpBackend {
         this.options.store.deleteThread(threadId);
         return { deleted: true };
     }
-    async sendThreadMessage(threadId, input, config) {
+    async sendThreadMessage(threadId, input, config, options = {}) {
         if (!config) {
             throw new Error('localcore-acp message send requires a workspace config.');
         }
@@ -199,7 +199,7 @@ class LocalCoreAcpBackend {
                 sessionKey: row.bridge_session_key,
             },
         });
-        void this.runPrompt(threadId, runId, row.bridge_session_key, config, message).catch((error) => {
+        void this.runPrompt(threadId, runId, row.bridge_session_key, config, message, options).catch((error) => {
             this.options.log?.(`localcore-acp prompt failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
         });
         return { runId };
@@ -283,7 +283,7 @@ class LocalCoreAcpBackend {
     async interruptRun(runId) {
         return this.sessionCoordinator.interruptRun(runId);
     }
-    async runPrompt(threadId, runId, bridgeSessionKey, config, input) {
+    async runPrompt(threadId, runId, bridgeSessionKey, config, input, options = {}) {
         const row = this.options.store.getThreadRow(threadId);
         if (!row) {
             throw new Error(`Thread not found: ${threadId}`);
@@ -297,7 +297,9 @@ class LocalCoreAcpBackend {
         const content = message.displayText;
         let session = null;
         try {
-            session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config);
+            session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config, {
+                permissionMode: options.permissionMode,
+            });
             session.currentRunId = runId;
             session.currentTurn = {
                 runId,

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

@@ -27,12 +27,14 @@ function applyAssistantMessageChunk(currentTurn, text) {
             bridgeType: 'preview_start',
             previewHandle: currentTurn.previewHandle,
             content: currentTurn.assistantText,
+            bridgeKind: 'assistant',
         };
     }
     return {
         bridgeType: 'update_message',
         previewHandle: currentTurn.previewHandle,
         content: currentTurn.assistantText,
+        bridgeKind: 'assistant',
     };
 }
 function applyThoughtChunk(currentTurn, text) {
@@ -40,7 +42,7 @@ function applyThoughtChunk(currentTurn, text) {
         return null;
     }
     currentTurn.thoughtText = mergeStreamingText(currentTurn.thoughtText, text);
-    const content = `💭 ${currentTurn.thoughtText.trim()}`;
+    const content = currentTurn.thoughtText.trim();
     if (!currentTurn.thoughtPreviewStarted) {
         currentTurn.thoughtPreviewStarted = true;
         return {
@@ -48,6 +50,7 @@ function applyThoughtChunk(currentTurn, text) {
             previewHandle: currentTurn.thoughtPreviewHandle,
             messageId: currentTurn.thoughtMessageId,
             content,
+            bridgeKind: 'thought',
         };
     }
     return {
@@ -55,6 +58,7 @@ function applyThoughtChunk(currentTurn, text) {
         previewHandle: currentTurn.thoughtPreviewHandle,
         messageId: currentTurn.thoughtMessageId,
         content,
+        bridgeKind: 'thought',
     };
 }
 function mergeStreamingText(current, next) {
@@ -177,7 +181,7 @@ function formatPlanProgress(entries) {
         .map((entry) => String(entry?.content || '').trim())
         .filter(Boolean)
         .join(' | ');
-    return summary ? `💭 ${summary}` : '';
+    return summary;
 }
 function extractToolCallKey(update) {
     for (const key of ['toolCallId', 'tool_call_id', 'callId', 'call_id', 'invocationId', 'invocation_id', 'id']) {

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

@@ -25,9 +25,13 @@ class LocalCoreAcpSessionCoordinator {
         this.options.transport.closeSession(session);
         this.sessions.delete(threadId);
     }
-    async ensureSession(threadId, bridgeSessionKey, config) {
+    async ensureSession(threadId, bridgeSessionKey, config, options = {}) {
         const existing = this.sessions.get(threadId);
-        if (existing && !existing.closed && existing.sessionId) {
+        const permissionMode = this.resolveLaunchPermissionMode(threadId, options.permissionMode);
+        if (existing
+            && !existing.closed
+            && existing.sessionId
+            && existing.launchPermissionMode === permissionMode) {
             return existing;
         }
         if (existing) {
@@ -43,6 +47,7 @@ class LocalCoreAcpSessionCoordinator {
             config,
             runtimeEnv: this.buildAgentRuntimeEnv(threadId, String(baseEnv.PATH || '')),
         });
+        session.launchPermissionMode = permissionMode;
         this.sessions.set(threadId, session);
         await this.options.transport.initializeSession(session);
         const row = this.options.store.getThreadRow(threadId);
@@ -68,7 +73,7 @@ class LocalCoreAcpSessionCoordinator {
                 const created = await this.options.transport.request(session, 'session/new', {
                     cwd: config.workDir,
                     mcpServers: [],
-                    _meta: this.buildSessionMeta(threadId),
+                    _meta: this.buildSessionMeta(threadId, permissionMode),
                 }, 30000);
                 session.sessionId = String(created.sessionId || created.session_id || created.id || created.session?.sessionId || created.session?.session_id || created.session?.id || '').trim();
                 if (!session.sessionId) {
@@ -182,10 +187,14 @@ class LocalCoreAcpSessionCoordinator {
         }
         return env;
     }
-    buildSessionMeta(threadId) {
+    resolveLaunchPermissionMode(threadId, permissionModeOverride = '') {
         const row = this.options.store.getThreadRow(threadId);
-        const mode = String(row?.agent_mode || '').trim();
-        if (!mode || mode === 'default') {
+        const mode = String(permissionModeOverride || row?.agent_mode || '').trim();
+        return !mode || mode === 'default' ? '' : mode;
+    }
+    buildSessionMeta(threadId, permissionModeOverride = '') {
+        const mode = this.resolveLaunchPermissionMode(threadId, permissionModeOverride);
+        if (!mode) {
             return undefined;
         }
         return {

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

@@ -41,6 +41,8 @@ class LocalCoreAcpStore {
         role TEXT NOT NULL,
         content TEXT NOT NULL,
         tool_call_json TEXT,
+        bridge_kind TEXT,
+        bridge_status TEXT,
         timestamp TEXT NOT NULL,
         kind TEXT NOT NULL,
         seq INTEGER NOT NULL,
@@ -222,6 +224,8 @@ class LocalCoreAcpStore {
       CREATE INDEX IF NOT EXISTS idx_audit_events_type_created ON audit_events (type, created_at DESC);
     `);
         this.ensureColumn('messages', 'tool_call_json', 'TEXT');
+        this.ensureColumn('messages', 'bridge_kind', 'TEXT');
+        this.ensureColumn('messages', 'bridge_status', 'TEXT');
         this.ensureColumn('scheduled_jobs', 'execution_mode', "TEXT NOT NULL DEFAULT 'same-thread'");
         this.ensureColumn('threads', 'agent_mode', "TEXT NOT NULL DEFAULT 'default'");
     }
@@ -284,7 +288,7 @@ class LocalCoreAcpStore {
             throw new Error(`Thread not found: ${threadId}`);
         }
         const messages = this.db.prepare(`
-      SELECT id, thread_id, role, content, tool_call_json, timestamp, kind, seq
+      SELECT id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq
       FROM messages
       WHERE thread_id = ?
       ORDER BY seq ASC
@@ -305,6 +309,8 @@ class LocalCoreAcpStore {
                 role: message.role,
                 content: message.content,
                 toolCall: parseJson(message.tool_call_json || 'null', null) || undefined,
+                bridgeKind: normalizeBridgeKind(message.bridge_kind),
+                bridgeStatus: normalizeBridgeStatus(message.bridge_status),
                 timestamp: message.timestamp,
                 kind: message.kind,
             })),
@@ -319,7 +325,7 @@ class LocalCoreAcpStore {
     deleteThread(threadId) {
         this.db.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
     }
-    appendMessage(threadId, role, content, kind, toolCall) {
+    appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
         const timestamp = new Date().toISOString();
         const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
         const nextSeq = Number(nextSequenceRow?.next_seq || 0);
@@ -328,9 +334,9 @@ class LocalCoreAcpStore {
         this.db.exec('BEGIN IMMEDIATE');
         try {
             this.db.prepare(`
-        INSERT INTO messages (id, thread_id, role, content, tool_call_json, timestamp, kind, seq)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, nextSeq);
+        INSERT INTO messages (id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, nextSeq);
             this.db.prepare(`
         UPDATE threads
         SET updated_at = ?, history_count = history_count + 1, excerpt = ?
@@ -344,7 +350,7 @@ class LocalCoreAcpStore {
         }
         return { id, timestamp };
     }
-    upsertMessage(threadId, id, role, content, kind, toolCall) {
+    upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
         const timestamp = new Date().toISOString();
         const excerpt = (0, workspace_thread_mappers_js_1.normalizeMessageContent)(content);
         const existing = this.db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(id, threadId);
@@ -353,17 +359,17 @@ class LocalCoreAcpStore {
             if (existing) {
                 this.db.prepare(`
           UPDATE messages
-          SET content = ?, tool_call_json = ?, timestamp = ?, kind = ?
+          SET content = ?, tool_call_json = ?, bridge_kind = ?, bridge_status = ?, timestamp = ?, kind = ?
           WHERE id = ? AND thread_id = ?
-        `).run(content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, id, threadId);
+        `).run(content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, id, threadId);
             }
             else {
                 const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
                 const nextSeq = Number(nextSequenceRow?.next_seq || 0);
                 this.db.prepare(`
-          INSERT INTO messages (id, thread_id, role, content, tool_call_json, timestamp, kind, seq)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, nextSeq);
+          INSERT INTO messages (id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, nextSeq);
                 this.db.prepare(`
           UPDATE threads
           SET history_count = history_count + 1
@@ -830,6 +836,9 @@ class LocalCoreAcpStore {
         return row ? this.toScheduledJob(row) : undefined;
     }
     createScheduledJob(input) {
+        if (!input.platform || !input.route) {
+            throw new Error('Scheduled job creation requires a resolved platform and route.');
+        }
         let id = (0, job_id_js_1.createScheduledJobId)();
         for (let attempt = 0; attempt < 5 && this.getScheduledJob(id); attempt += 1) {
             id = (0, job_id_js_1.createScheduledJobId)();
@@ -1301,6 +1310,22 @@ function parseJson(value, fallback) {
         return fallback;
     }
 }
+function normalizeBridgeKind(value) {
+    switch (value) {
+        case 'assistant':
+        case 'thought':
+        case 'plan':
+        case 'tool':
+        case 'status':
+        case 'permission':
+            return value;
+        default:
+            return undefined;
+    }
+}
+function normalizeBridgeStatus(value) {
+    return value === 'awaiting_input' ? value : undefined;
+}
 function defaultPermissions() {
     return {
         'workspace.read': 'allow',

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

@@ -38,6 +38,7 @@ class LocalCoreAcpTransport {
             closed: false,
             closeReason: null,
             promptPromise: null,
+            launchPermissionMode: '',
         };
         child.stdout.setEncoding('utf8');
         child.stdout.on('data', (chunk) => this.handleStdout(session, chunk));

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

@@ -160,11 +160,13 @@ class LocalCoreAcpTurnCoordinator {
         });
         this.options.updateRunStatus(currentRunId, session.threadId, 'awaiting_input');
         const permissionPrompt = (0, local_core_acp_permission_lifecycle_js_1.createPermissionPrompt)(toolTitle);
-        this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress');
+        this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress', undefined, 'permission', 'awaiting_input');
         this.options.emitBridge({
             type: 'buttons',
             sessionKey: session.bridgeSessionKey,
             replyCtx: currentRunId,
+            bridgeKind: 'permission',
+            bridgeStatus: 'awaiting_input',
             content: permissionPrompt,
             buttonRows,
         });
@@ -194,6 +196,7 @@ class LocalCoreAcpTurnCoordinator {
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
                     previewHandle: projection.previewHandle,
+                    bridgeKind: projection.bridgeKind,
                     content: projection.content,
                 });
                 return;
@@ -208,13 +211,14 @@ class LocalCoreAcpTurnCoordinator {
                     return;
                 }
                 if (this.options.upsertMessage) {
-                    this.options.upsertMessage(session.threadId, projection.messageId, 'assistant', projection.content, 'progress');
+                    this.options.upsertMessage(session.threadId, projection.messageId, 'assistant', projection.content, 'progress', undefined, projection.bridgeKind);
                 }
                 this.options.emitBridge({
                     type: projection.bridgeType,
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
                     previewHandle: projection.previewHandle,
+                    bridgeKind: projection.bridgeKind,
                     content: projection.content,
                 });
                 return;
@@ -290,11 +294,12 @@ class LocalCoreAcpTurnCoordinator {
                 if (!content) {
                     return;
                 }
-                this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+                this.options.appendMessage(session.threadId, 'assistant', content, 'progress', undefined, 'plan');
                 this.options.emitBridge({
                     type: 'reply',
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
+                    bridgeKind: 'plan',
                     content,
                 });
                 return;
@@ -305,16 +310,17 @@ class LocalCoreAcpTurnCoordinator {
     }
     emitProgress(session, currentRunId, content, messageId, toolCall) {
         if (messageId && this.options.upsertMessage) {
-            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall);
+            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall, toolCall ? 'tool' : undefined);
         }
         else {
-            this.options.appendMessage(session.threadId, 'assistant', content, 'progress', toolCall);
+            this.options.appendMessage(session.threadId, 'assistant', content, 'progress', toolCall, toolCall ? 'tool' : undefined);
         }
         this.options.emitBridge({
             type: 'reply',
             sessionKey: session.bridgeSessionKey,
             replyCtx: currentRunId,
             messageId,
+            bridgeKind: toolCall ? 'tool' : undefined,
             content,
             toolCall,
         });

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

@@ -31,31 +31,25 @@ function createLarkTurnState(sessionKey, sourceMessageId) {
     return turn;
 }
 function foldToolResultForLark(content) {
-    const normalized = String(content || '').trim();
-    if (!normalized.startsWith('🔧 '))
-        return normalized;
-    const parts = normalized.split(' - ');
-    if (parts.length <= 2)
-        return normalized;
-    return parts.slice(0, 2).join(' - ');
+    return String(content || '').trim();
 }
 function summarizeToolCallForLark(event, content) {
     const toolCall = event.toolCall;
     if (toolCall) {
         const name = String(toolCall.name || '').trim() || summarizeToolContentForLark(content);
         const input = formatToolInputForLark(toolCall.input);
-        return [name.startsWith('🔧 ') ? name : `🔧 ${name}`, input ? `参数：${input}` : '']
+        return [`🔧 ${name}`, input ? `参数：${input}` : '']
             .filter(Boolean)
             .join('\n\n');
     }
     return summarizeToolContentForLark(content);
 }
-function isPendingToolProgressForLark(content) {
-    const normalized = foldToolResultForLark(content).toLowerCase();
-    return normalized.startsWith('🔧 ') && normalized.includes(' - pending');
+function isPendingToolProgressForLark(event) {
+    return event.toolCall?.status.trim().toLowerCase() === 'pending';
 }
 function consumeLarkBridgeEvent(turn, event, options) {
     const content = foldToolResultForLark(String(event.content || '').trim());
+    const bridgeKind = resolveBridgeEventKind(event);
     if (event.type === 'typing_start') {
         turn.messageId = undefined;
         turn.finalMessageId = undefined;
@@ -80,10 +74,10 @@ function consumeLarkBridgeEvent(turn, event, options) {
         return;
     }
     if (event.type === 'preview_start' || event.type === 'update_message') {
-        if (content.startsWith('💭 ')) {
+        if (bridgeKind === 'thought') {
             turn.pendingThoughtKey = event.previewHandle || 'thinking-preview';
             turn.pendingThoughtText = content;
-            pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
+            pushUniqueLarkTurnLine(turn.thinkingSteps, content);
             return;
         }
         turn.previewText = content;
@@ -106,17 +100,17 @@ function consumeLarkBridgeEvent(turn, event, options) {
     if (!content) {
         return;
     }
-    if (content.startsWith('💭 ')) {
+    if (bridgeKind === 'thought' || bridgeKind === 'plan') {
         turn.pendingThoughtKey = progressKey('thinking', event);
         turn.pendingThoughtText = content;
-        pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
+        pushUniqueLarkTurnLine(turn.thinkingSteps, content);
         return;
     }
-    if (content.startsWith('🔧 ')) {
+    if (bridgeKind === 'tool') {
         pushUniqueLarkTurnLine(turn.toolCalls, content.slice(3).trim());
         return;
     }
-    if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+    if (bridgeKind === 'status') {
         pushUniqueLarkTurnLine(turn.statusLines, content.slice(3).trim());
         return;
     }
@@ -125,12 +119,13 @@ function consumeLarkBridgeEvent(turn, event, options) {
 }
 function renderLarkBridgeEventMessage(turn, event) {
     const content = foldToolResultForLark(String(event.content || '').trim());
+    const bridgeKind = resolveBridgeEventKind(event);
     if (event.type === 'preview_start' || event.type === 'update_message') {
-        if (content.startsWith('💭 ')) {
+        if (bridgeKind === 'thought') {
             return { key: 'noop', text: '', buttonRows: [], isFinal: false };
         }
-        if (content.startsWith('🔧 ')) {
-            if (isPendingToolProgressForLark(content)) {
+        if (bridgeKind === 'tool') {
+            if (isPendingToolProgressForLark(event)) {
                 return { key: 'noop', text: '', buttonRows: [], isFinal: false };
             }
             return renderToolMessage(progressKey('tool', event), summarizeToolCallForLark(event, content));
@@ -138,19 +133,19 @@ function renderLarkBridgeEventMessage(turn, event) {
         return { key: 'noop', text: '', buttonRows: [], isFinal: false };
     }
     if (event.type === 'status') {
-        return renderProgressMessage(progressKey('status', event), content.startsWith('⏳ ') ? content : `⏳ ${content}`);
+        return renderProgressMessage(progressKey('status', event), `⏳ ${content}`);
     }
     if (event.type === 'reply') {
-        if (content.startsWith('💭 ')) {
-            return { key: 'noop', text: '', buttonRows: [], isFinal: false };
+        if (bridgeKind === 'thought' || bridgeKind === 'plan') {
+            return renderProgressMessage(progressKey(bridgeKind, event), renderProcessText(bridgeKind, content));
         }
-        if (content.startsWith('🔧 ')) {
-            if (isPendingToolProgressForLark(content)) {
+        if (bridgeKind === 'tool') {
+            if (isPendingToolProgressForLark(event)) {
                 return { key: 'noop', text: '', buttonRows: [], isFinal: false };
             }
             return renderToolMessage(progressKey('tool', event), summarizeToolCallForLark(event, content));
         }
-        if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+        if (bridgeKind === 'status') {
             return renderProgressMessage(progressKey('status', event), content);
         }
         return {
@@ -186,7 +181,7 @@ function takePendingLarkThoughtRender(turn) {
     }
     turn.thoughtSegmentSequence += 1;
     const baseKey = turn.pendingThoughtKey || 'thinking-preview';
-    const rendered = renderProgressMessage(`thinking:${baseKey}:${turn.thoughtSegmentSequence}`, text);
+    const rendered = renderProgressMessage(`thinking:${baseKey}:${turn.thoughtSegmentSequence}`, renderProcessText('thought', text));
     turn.pendingThoughtKey = undefined;
     turn.pendingThoughtText = undefined;
     return rendered;
@@ -229,21 +224,21 @@ function progressKey(prefix, event) {
     return `${prefix}:${content.slice(0, 120)}`;
 }
 function isThoughtBridgeEvent(event) {
-    if (event.type !== 'preview_start' && event.type !== 'update_message' && event.type !== 'reply') {
-        return false;
+    const kind = resolveBridgeEventKind(event);
+    return kind === 'thought' || kind === 'plan';
+}
+function resolveBridgeEventKind(event) {
+    if (event.bridgeKind) {
+        return event.bridgeKind;
     }
-    return String(event.content || '').trim().startsWith('💭 ');
+    return event.type === 'status' ? 'status' : 'assistant';
+}
+function renderProcessText(kind, content) {
+    const text = content.trim();
+    return kind === 'plan' ? `计划\n${text}` : text;
 }
 function summarizeToolContentForLark(content) {
-    const normalized = String(content || '').trim();
-    if (!normalized.startsWith('🔧 ')) {
-        return normalized;
-    }
-    const withoutOutput = normalized.split(' - ')[0]?.trim() || normalized;
-    return withoutOutput
-        .replace(/\s+-\s*(running|pending|completed|failed|error|cancelled|canceled)\s*$/i, '')
-        .replace(/:\s*(running|pending|completed|failed|error|cancelled|canceled)\s*$/i, '')
-        .trim();
+    return String(content || '').trim();
 }
 function formatToolInputForLark(input) {
     if (input == null) {