@kafca/agentdock 0.1.40 → 0.1.42

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

@@ -1,18 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildLarkPostContent = buildLarkPostContent;
-function buildLarkPostContent(markdown) {
-    return {
-        zh_cn: {
-            content: [[{
-                        tag: 'md',
-                        text: sanitizeLarkPostMarkdown(String(markdown || '').trim() || ' '),
-                    }]],
-        },
-    };
-}
-function sanitizeLarkPostMarkdown(markdown) {
-    return markdown.replace(/\[([^\]]*)\]\(([^)]+)\)/g, (match, label, href) => {
-        return /^https?:\/\//i.test(href) ? match : `${label} (${href})`;
-    });
-}
+exports.shouldUseLarkMarkdownCard = exports.renderLarkTextMessage = exports.normalizeMarkdownTablesForLarkPost = exports.buildLarkPostContent = exports.buildLarkMarkdownCardContent = void 0;
+var messages_js_1 = require("./rendering/messages.js");
+Object.defineProperty(exports, "buildLarkMarkdownCardContent", { enumerable: true, get: function () { return messages_js_1.buildLarkMarkdownCardContent; } });
+Object.defineProperty(exports, "buildLarkPostContent", { enumerable: true, get: function () { return messages_js_1.buildLarkPostContent; } });
+Object.defineProperty(exports, "normalizeMarkdownTablesForLarkPost", { enumerable: true, get: function () { return messages_js_1.normalizeMarkdownTablesForLarkPost; } });
+Object.defineProperty(exports, "renderLarkTextMessage", { enumerable: true, get: function () { return messages_js_1.renderLarkTextMessage; } });
+Object.defineProperty(exports, "shouldUseLarkMarkdownCard", { enumerable: true, get: function () { return messages_js_1.shouldUseLarkMarkdownCard; } });

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LARK_CARD_MARKDOWN_TABLE_LIMIT = void 0;
+exports.sanitizeLarkMarkdown = sanitizeLarkMarkdown;
+exports.countMarkdownTables = countMarkdownTables;
+exports.shouldUseLarkMarkdownCard = shouldUseLarkMarkdownCard;
+exports.normalizeMarkdownTablesForLarkPost = normalizeMarkdownTablesForLarkPost;
+exports.LARK_CARD_MARKDOWN_TABLE_LIMIT = 5;
+function sanitizeLarkMarkdown(markdown) {
+    return markdown.replace(/\[([^\]]*)\]\(([^)]+)\)/g, (match, label, href) => {
+        return /^https?:\/\//i.test(href) ? match : `${label} (${href})`;
+    });
+}
+function countMarkdownTables(markdown) {
+    const lines = String(markdown || '').split('\n');
+    let count = 0;
+    let inTable = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const isTableStart = isMarkdownTableLine(lines[index]) && isMarkdownTableSeparatorLine(lines[index + 1]);
+        const isTableBody = inTable && isMarkdownTableLine(lines[index]);
+        if (isTableStart && !inTable) {
+            count += 1;
+            inTable = true;
+            continue;
+        }
+        if (!isTableBody) {
+            inTable = false;
+        }
+    }
+    return count;
+}
+function shouldUseLarkMarkdownCard(markdown) {
+    const tableCount = countMarkdownTables(markdown);
+    return tableCount > 0 && tableCount <= exports.LARK_CARD_MARKDOWN_TABLE_LIMIT;
+}
+function normalizeMarkdownTablesForLarkPost(markdown) {
+    const lines = markdown.split('\n');
+    const output = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (isMarkdownTableLine(lines[index]) && isMarkdownTableSeparatorLine(lines[index + 1])) {
+            const tableLines = [lines[index], lines[index + 1]];
+            index += 2;
+            while (index < lines.length && isMarkdownTableLine(lines[index])) {
+                tableLines.push(lines[index]);
+                index += 1;
+            }
+            index -= 1;
+            output.push(renderMarkdownTableAsList(tableLines));
+            continue;
+        }
+        output.push(lines[index]);
+    }
+    return output.join('\n');
+}
+function isMarkdownTableLine(line) {
+    const trimmed = String(line || '').trim();
+    return trimmed.length > 1 && trimmed.startsWith('|') && trimmed.endsWith('|');
+}
+function isMarkdownTableSeparatorLine(line) {
+    if (!isMarkdownTableLine(line)) {
+        return false;
+    }
+    const cells = splitMarkdownTableRow(String(line));
+    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
+}
+function splitMarkdownTableRow(line) {
+    return line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((cell) => cell.trim());
+}
+function renderMarkdownTableAsList(tableLines) {
+    const headers = splitMarkdownTableRow(tableLines[0] || '');
+    const bodyRows = tableLines.slice(2).map(splitMarkdownTableRow);
+    if (headers.length === 0 || bodyRows.length === 0) {
+        return tableLines.join('\n');
+    }
+    return bodyRows
+        .map((cells, rowIndex) => renderMarkdownTableRow(headers, cells, rowIndex))
+        .join('\n');
+}
+function renderMarkdownTableRow(headers, cells, rowIndex) {
+    const hasNumberColumn = headers[0]?.trim() === '#';
+    const explicitNumber = hasNumberColumn ? cells[0]?.trim() : '';
+    const prefix = explicitNumber && /^\d+$/.test(explicitNumber) ? `${explicitNumber}.` : `${rowIndex + 1}.`;
+    const startIndex = hasNumberColumn ? 1 : 0;
+    const parts = [];
+    for (let index = startIndex; index < headers.length; index += 1) {
+        const header = headers[index]?.trim();
+        const value = cells[index]?.trim();
+        if (!header || !value) {
+            continue;
+        }
+        parts.push(`${header}: ${value}`);
+    }
+    return parts.length > 0 ? `${prefix} ${parts.join('；')}` : `${prefix} ${cells.join('；')}`;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseLarkMarkdownCard = exports.normalizeMarkdownTablesForLarkPost = void 0;
+exports.renderLarkTextMessage = renderLarkTextMessage;
+exports.buildLarkPostContent = buildLarkPostContent;
+exports.buildLarkMarkdownCardContent = buildLarkMarkdownCardContent;
+const markdown_js_1 = require("./markdown.js");
+Object.defineProperty(exports, "normalizeMarkdownTablesForLarkPost", { enumerable: true, get: function () { return markdown_js_1.normalizeMarkdownTablesForLarkPost; } });
+Object.defineProperty(exports, "shouldUseLarkMarkdownCard", { enumerable: true, get: function () { return markdown_js_1.shouldUseLarkMarkdownCard; } });
+function renderLarkTextMessage(markdown) {
+    const tableCount = (0, markdown_js_1.countMarkdownTables)(markdown);
+    if ((0, markdown_js_1.shouldUseLarkMarkdownCard)(markdown)) {
+        return {
+            msgType: 'interactive',
+            content: buildLarkMarkdownCardContent(markdown),
+            renderKind: 'markdown_card',
+            reason: 'markdown_table',
+            tableCount,
+        };
+    }
+    return {
+        msgType: 'post',
+        content: buildLarkPostContent(markdown),
+        renderKind: 'post_md',
+        reason: tableCount > 0 ? 'table_limit_fallback' : 'plain_markdown',
+        tableCount,
+    };
+}
+function buildLarkPostContent(markdown) {
+    const normalized = (0, markdown_js_1.normalizeMarkdownTablesForLarkPost)(String(markdown || '').trim() || ' ');
+    return {
+        zh_cn: {
+            content: [[{
+                        tag: 'md',
+                        text: (0, markdown_js_1.sanitizeLarkMarkdown)(normalized),
+                    }]],
+        },
+    };
+}
+function buildLarkMarkdownCardContent(markdown) {
+    return {
+        schema: '2.0',
+        config: { wide_screen_mode: true },
+        body: {
+            elements: [{
+                    tag: 'markdown',
+                    content: (0, markdown_js_1.sanitizeLarkMarkdown)(String(markdown || '').trim() || ' '),
+                }],
+        },
+    };
+}

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

@@ -114,6 +114,10 @@ function consumeLarkBridgeEvent(turn, event, options) {
         pushUniqueLarkTurnLine(turn.statusLines, content.slice(3).trim());
         return;
     }
+    if (bridgeKind === 'assistant' && event.messageId) {
+        turn.previewText = content;
+        return;
+    }
     turn.finalText = content;
     turn.previewText = content;
 }
@@ -148,6 +152,9 @@ function renderLarkBridgeEventMessage(turn, event) {
         if (bridgeKind === 'status') {
             return renderProgressMessage(progressKey('status', event), content);
         }
+        if (bridgeKind === 'assistant' && event.messageId) {
+            return renderAssistantSegmentMessage(progressKey('assistant', event), content);
+        }
         return {
             key: 'final',
             text: content,
@@ -217,6 +224,13 @@ function renderToolMessage(key, text) {
         updatePolicy: 'create-only',
     };
 }
+function renderAssistantSegmentMessage(key, text) {
+    return {
+        ...renderProgressMessage(key, text),
+        delivery: 'message',
+        updatePolicy: 'create-only',
+    };
+}
 function progressKey(prefix, event) {
     const stableId = String(event.messageId || event.previewHandle || '').trim();
     if (stableId) {

package/dist-electron/services/local-ai-core/src/router/workspace-router.js

@@ -48,6 +48,7 @@ class WorkspaceRouter {
                     return this.schedulerBridge.deleteJob(jobId);
                 },
             },
+            getAgentTypes: () => this.options.getCapabilities().snapshot.agents.map((agent) => agent.agentType),
             log: options.log,
         });
     }
@@ -203,12 +204,14 @@ class WorkspaceRouter {
     }
     async sendThreadMessage(threadId, content, options) {
         const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
-        const route = await this.getWorkspaceRoute(workspaceId);
+        const route = isLocalSlashCommand(content)
+            ? await this.getWorkspaceRoute(workspaceId)
+            : await this.getThreadWorkspaceRoute(threadId, workspaceId);
         return this.localCoreAcp.sendThreadMessage(threadId, content, route.config, options);
     }
     async sendThreadAction(threadId, content) {
         const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
-        const route = await this.getWorkspaceRoute(workspaceId);
+        const route = await this.getThreadWorkspaceRoute(threadId, workspaceId);
         return this.localCoreAcp.sendThreadAction(threadId, content, route.config);
     }
     async interruptRun(runId) {
@@ -425,11 +428,21 @@ class WorkspaceRouter {
             await this.localCoreAcp.deleteThread(thread.id).catch(() => ({ deleted: false }));
         }
     }
-    async getWorkspaceRoute(workspaceId) {
+    async getThreadWorkspaceRoute(threadId, workspaceId) {
+        const defaultRoute = await this.getWorkspaceRoute(workspaceId);
+        const row = this.store.getThreadRow(threadId);
+        const threadAgentType = String(row?.agent_type || '').trim().toLowerCase();
+        if (!threadAgentType || threadAgentType === defaultRoute.agentType) {
+            return defaultRoute;
+        }
+        return this.getWorkspaceRoute(workspaceId, threadAgentType);
+    }
+    async getWorkspaceRoute(workspaceId, agentTypeOverride = '') {
         const configState = await this.options.readConfigState();
         const projects = Array.isArray(configState.parsed?.projects) ? configState.parsed.projects : [];
         const matched = projects.find((project) => String(project?.name || '').trim() === workspaceId);
-        const route = matched ? this.resolveProjectRoute(configState, matched) : null;
+        const project = matched && agentTypeOverride ? withAgentTypeOverride(matched, agentTypeOverride) : matched;
+        const route = project ? this.resolveProjectRoute(configState, project) : null;
         if (!matched || !route) {
             throw new Error(`Workspace "${workspaceId}" is not configured as a Local AI Core ACP workspace.`);
         }
@@ -512,6 +525,29 @@ function inferWorkspacePath(project) {
     }
     return '';
 }
+function withAgentTypeOverride(project, agentType) {
+    const options = project.agent?.options && typeof project.agent.options === 'object'
+        ? { ...project.agent.options }
+        : {};
+    delete options.command;
+    delete options.args;
+    return {
+        ...project,
+        agent: {
+            ...(project.agent || {}),
+            type: agentType,
+            options,
+        },
+    };
+}
+function isLocalSlashCommand(content) {
+    const text = typeof content === 'string' ? content : String(content.displayText || '');
+    const normalized = text.trim().toLowerCase();
+    return normalized === '/agent'
+        || normalized.startsWith('/agent ')
+        || normalized === '/mode'
+        || normalized.startsWith('/mode ');
+}
 function workspaceHealth(path) {
     if (!path) {
         return {

package/dist-electron/services/local-ai-core/src/thread/thread-command-service.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadCommandService = void 0;
+const local_core_slash_commands_js_1 = require("../acp/local-core-slash-commands.js");
+const index_js_1 = require("../agents/index.js");
+class ThreadCommandService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(input) {
+        const command = (0, local_core_slash_commands_js_1.parseSlashCommand)(input.content);
+        if (!command) {
+            return { handled: false, displayText: '' };
+        }
+        if (command.name === 'mode') {
+            return {
+                handled: true,
+                displayText: await this.executeModeCommand(input.threadId, input.workspaceId, command.args),
+            };
+        }
+        if (command.name === 'agent') {
+            return {
+                handled: true,
+                displayText: this.executeAgentCommand(input.threadId, input.workspaceId, command.args, input.defaultAgentType),
+            };
+        }
+        return { handled: false, displayText: '' };
+    }
+    async executeModeCommand(threadId, workspaceId, args) {
+        const row = this.options.getThreadRow(threadId);
+        const currentMode = row?.agent_mode || local_core_slash_commands_js_1.DEFAULT_AGENT_MODE;
+        const requested = args.join(' ').trim();
+        if (!requested) {
+            return (0, local_core_slash_commands_js_1.modeHelpText)(currentMode);
+        }
+        const mode = (0, local_core_slash_commands_js_1.normalizeAgentMode)(requested);
+        if (!mode) {
+            return `未知模式：${requested}\n\n${(0, local_core_slash_commands_js_1.modeHelpText)(currentMode)}`;
+        }
+        this.options.updateThreadAgentMode(threadId, mode);
+        try {
+            await this.options.setThreadMode?.(threadId, mode);
+        }
+        catch (error) {
+            this.options.log?.(`localcore-acp mode sync failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        this.options.createAuditEvent({
+            type: 'permission.changed',
+            workspaceId,
+            actor: 'local',
+            summary: `Thread agent mode changed to ${mode}.`,
+            metadata: { threadId, mode },
+        });
+        if (mode === 'bypassPermissions') {
+            return '已切换到 yolo 模式：后续工具调用会跳过权限申请。使用 `/mode default` 可恢复默认权限。';
+        }
+        return `已切换到 ${(0, local_core_slash_commands_js_1.formatAgentMode)(mode)} 模式。`;
+    }
+    executeAgentCommand(threadId, workspaceId, args, defaultAgentType) {
+        const row = this.options.getThreadRow(threadId);
+        const currentAgent = (0, local_core_slash_commands_js_1.normalizeAgentCommandTarget)(row?.agent_type || defaultAgentType);
+        const defaultAgent = (0, local_core_slash_commands_js_1.normalizeAgentCommandTarget)(defaultAgentType);
+        const availableAgents = (0, local_core_slash_commands_js_1.formatAgentList)(this.options.getAgentTypes?.() || [defaultAgent, currentAgent]);
+        const [rawAction = '', ...rest] = args;
+        const action = String(rawAction || '').trim().toLowerCase();
+        if (!action || action === 'current') {
+            return [
+                `当前线程 Agent：${currentAgent}`,
+                `来源：${currentAgent === defaultAgent ? '默认设置' : '线程设置'}`,
+                `默认 Agent：${defaultAgent}`,
+                '使用 `/agent list` 查看可用 Agent，或 `/agent use <agent-id>` 切换。',
+            ].join('\n');
+        }
+        if (action === 'list') {
+            return (0, local_core_slash_commands_js_1.agentHelpText)({ currentAgent, defaultAgent, availableAgents });
+        }
+        if (action === 'reset') {
+            if (currentAgent === defaultAgent) {
+                return `当前线程已经使用默认 Agent：${defaultAgent}。`;
+            }
+            const activeRun = this.hasActiveRun(threadId);
+            this.options.updateThreadAgentType(threadId, defaultAgent);
+            if (!activeRun) {
+                this.options.closeThreadSession?.(threadId);
+            }
+            this.options.createAuditEvent({
+                type: 'agent.changed',
+                workspaceId,
+                actor: 'local',
+                summary: `Thread agent reset to ${defaultAgent}.`,
+                metadata: { threadId, agentType: defaultAgent, previousAgentType: currentAgent },
+            });
+            return `已清除当前线程 Agent 设置。\n当前线程将回到默认 Agent：${defaultAgent}。`;
+        }
+        const rawRequested = action === 'use' ? rest.join(' ').trim() : args.join(' ').trim();
+        const requestedAgent = (0, local_core_slash_commands_js_1.normalizeAgentCommandTarget)(rawRequested);
+        if (!requestedAgent) {
+            return (0, local_core_slash_commands_js_1.agentHelpText)({ currentAgent, defaultAgent, availableAgents });
+        }
+        const definition = (0, index_js_1.resolveAgentRuntimeDefinition)(requestedAgent);
+        if (!definition) {
+            return `未知 Agent：${rawRequested}\n可用 Agent：${availableAgents.length ? availableAgents.join(', ') : '无'}`;
+        }
+        const canonicalAgent = definition.agentType;
+        if (!availableAgents.includes(canonicalAgent)) {
+            return `Agent "${canonicalAgent}" 当前不可用。\n可用 Agent：${availableAgents.length ? availableAgents.join(', ') : '无'}`;
+        }
+        if (canonicalAgent === currentAgent) {
+            return `当前线程已经使用 Agent：${canonicalAgent}。`;
+        }
+        const activeRun = this.hasActiveRun(threadId);
+        this.options.updateThreadAgentType(threadId, canonicalAgent);
+        if (!activeRun) {
+            this.options.closeThreadSession?.(threadId);
+        }
+        const runningNote = activeRun
+            ? `\n当前正在运行的任务仍会继续使用 ${currentAgent}，下一轮开始生效。`
+            : '';
+        this.options.createAuditEvent({
+            type: 'agent.changed',
+            workspaceId,
+            actor: 'local',
+            summary: `Thread agent changed to ${canonicalAgent}.`,
+            metadata: { threadId, agentType: canonicalAgent, previousAgentType: currentAgent },
+        });
+        return `已将当前线程 Agent 切换为 ${canonicalAgent}。\n后续消息将使用 ${canonicalAgent} 处理。${runningNote}`;
+    }
+    hasActiveRun(threadId) {
+        const latestRun = this.options.getLatestRunForThread(threadId);
+        return Boolean(latestRun && ['queued', 'running', 'awaiting_input'].includes(latestRun.status));
+    }
+}
+exports.ThreadCommandService = ThreadCommandService;

package/dist-electron/tests/electron/plugin-kernel.test.js

@@ -302,6 +302,32 @@ type = "codex"
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('thread slash agent reset resolves the workspace default agent through the router', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-agent-reset-'));
+    try {
+        const runtime = (0, bootstrap_js_2.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+        });
+        await runtime.state.saveRawConfigFile(`
+[[projects]]
+name = "agent-workspace"
+
+[projects.agent]
+type = "codex"
+`);
+        const thread = await runtime.workspaceRouter.createThread('agent-workspace', 'Agent reset');
+        await runtime.workspaceRouter.sendThreadMessage(thread.id, '/agent use pi');
+        strict_1.default.equal(runtime.store.getThreadRow(thread.id)?.agent_type, 'pi');
+        await runtime.workspaceRouter.sendThreadMessage(thread.id, '/agent reset');
+        strict_1.default.equal(runtime.store.getThreadRow(thread.id)?.agent_type, 'codex');
+        strict_1.default.match(runtime.store.getThread(thread.id, []).messages.at(-1)?.content || '', /回到默认 Agent：codex/);
+        await runtime.stop();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('hermes agent runtime routes projects through hermes ACP command', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
     try {

package/dist-electron/tests/integration/lark-rendering.test.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const local_core_lark_gateway_js_1 = require("../../services/local-ai-core/src/channel/lark/local-core-lark-gateway.js");
+const messages_js_1 = require("../../services/local-ai-core/src/channel/lark/rendering/messages.js");
+function findLarkPostMdText(content) {
+    for (const line of content.zh_cn?.content || []) {
+        for (const item of Array.isArray(line) ? line : []) {
+            if (item?.tag === 'md') {
+                return String(item.text || '');
+            }
+        }
+    }
+    return '';
+}
+function tableMarkdown(index) {
+    return [
+        `| # | 标题 | 状态 | 一句话 |`,
+        `|---|------|------|--------|`,
+        `| ${index} | **标题 ${index}** | 待处理 | 摘要 ${index} |`,
+    ].join('\n');
+}
+(0, node_test_1.default)('lark text renderer keeps plain markdown on post messages', () => {
+    const rendered = (0, messages_js_1.renderLarkTextMessage)('### 标题\n\n普通回复');
+    strict_1.default.equal(rendered.msgType, 'post');
+    strict_1.default.equal(rendered.renderKind, 'post_md');
+    strict_1.default.equal(rendered.reason, 'plain_markdown');
+    strict_1.default.equal(rendered.tableCount, 0);
+    strict_1.default.equal(findLarkPostMdText(rendered.content), '### 标题\n\n普通回复');
+});
+(0, node_test_1.default)('lark text renderer sends markdown tables through schema 2.0 cards', () => {
+    const markdown = [
+        '### 各收件内容摘要',
+        '',
+        tableMarkdown(1),
+    ].join('\n');
+    const rendered = (0, messages_js_1.renderLarkTextMessage)(markdown);
+    strict_1.default.equal(rendered.msgType, 'interactive');
+    strict_1.default.equal(rendered.renderKind, 'markdown_card');
+    strict_1.default.equal(rendered.reason, 'markdown_table');
+    strict_1.default.equal(rendered.tableCount, 1);
+    strict_1.default.equal(rendered.content.schema, '2.0');
+    strict_1.default.equal(rendered.content.body?.elements?.[0]?.tag, 'markdown');
+    strict_1.default.match(rendered.content.body?.elements?.[0]?.content || '', /\| 1 \| \*\*标题 1\*\* \| 待处理 \|/);
+});
+(0, node_test_1.default)('lark post fallback renders markdown table rows as visible text', () => {
+    const content = (0, messages_js_1.buildLarkPostContent)([
+        '### 各收件内容摘要',
+        '',
+        tableMarkdown(1),
+        tableMarkdown(2),
+        tableMarkdown(3),
+        tableMarkdown(4),
+        tableMarkdown(5),
+        tableMarkdown(6),
+        '',
+        '需要我对哪个文件做进一步处理？',
+    ].join('\n'));
+    const text = findLarkPostMdText(content);
+    strict_1.default.doesNotMatch(text, /\|---\|/);
+    strict_1.default.match(text, /1\. 标题: \*\*标题 1\*\*；状态: 待处理；一句话: 摘要 1/);
+    strict_1.default.match(text, /6\. 标题: \*\*标题 6\*\*；状态: 待处理；一句话: 摘要 6/);
+    strict_1.default.match(text, /需要我对哪个文件做进一步处理？/);
+});
+(0, node_test_1.default)('lark text renderer falls back to post when card table count exceeds the platform limit', () => {
+    const rendered = (0, messages_js_1.renderLarkTextMessage)([
+        tableMarkdown(1),
+        tableMarkdown(2),
+        tableMarkdown(3),
+        tableMarkdown(4),
+        tableMarkdown(5),
+        tableMarkdown(6),
+    ].join('\n\n'));
+    strict_1.default.equal(rendered.msgType, 'post');
+    strict_1.default.equal(rendered.renderKind, 'post_md');
+    strict_1.default.equal(rendered.reason, 'table_limit_fallback');
+    strict_1.default.equal(rendered.tableCount, 6);
+    strict_1.default.match(findLarkPostMdText(rendered.content), /6\. 标题: \*\*标题 6\*\*/);
+});
+(0, node_test_1.default)('lark text renderer sanitizes non-http markdown links', () => {
+    const rendered = (0, messages_js_1.renderLarkTextMessage)('[本地文件](file:///tmp/a.md) 和 [官网](https://example.com)');
+    const text = findLarkPostMdText(rendered.content);
+    strict_1.default.match(text, /本地文件 \(file:\/\/\/tmp\/a\.md\)/);
+    strict_1.default.match(text, /\[官网\]\(https:\/\/example\.com\)/);
+});
+(0, node_test_1.default)('lark gateway sends rendered text message payloads without owning render strategy', async () => {
+    const requests = [];
+    const logs = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {},
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+        log: (line) => logs.push(line),
+    });
+    const result = await gateway.sendTextAsMessage({
+        client: {
+            im: {
+                message: {
+                    create: async (request) => {
+                        requests.push(request);
+                        return { data: { message_id: 'lark-msg-1' } };
+                    },
+                },
+            },
+        },
+    }, 'chat-1', [
+        '### 各收件内容摘要',
+        '',
+        tableMarkdown(1),
+    ].join('\n'));
+    const request = requests[0];
+    const content = JSON.parse(String(request?.data?.content || '{}'));
+    strict_1.default.equal(result.messageId, 'lark-msg-1');
+    strict_1.default.equal(result.renderKind, 'markdown_card');
+    strict_1.default.equal(request?.data?.msg_type, 'interactive');
+    strict_1.default.equal(content.schema, '2.0');
+    strict_1.default.match(logs.join('\n'), /msgType=interactive reason=markdown_table tableCount=1/);
+});