team-anya-cli 0.1.0

package/packages/mcp-tools/dist/layer2/loid/delivery-upload.js

@@ -0,0 +1,18 @@
+import { fileUpload } from '../../layer3/file-upload.js';
+/**
+ * delivery.upload - 上传文件产物
+ *
+ * 委托给 file.upload 实现。target 参数暂不使用（预留给后续上传到指定位置的场景）。
+ */
+export async function deliveryUpload(deps, input) {
+    const result = await fileUpload(deps, {
+        file_path: input.file_path,
+    });
+    return {
+        status: 'uploaded',
+        url: result.url,
+        file_name: result.file_name,
+        file_size: result.file_size,
+    };
+}
+//# sourceMappingURL=delivery-upload.js.map

package/packages/mcp-tools/dist/layer2/loid/project-remove.js

@@ -0,0 +1,16 @@
+import { getProject, softDeleteProject, insertAuditEvent } from '@team-anya/db';
+export async function projectRemove(db, _workspacePath, input) {
+    const existing = getProject(db, input.project_id);
+    if (!existing) {
+        return { removed: false, message: `Project ${input.project_id} not found` };
+    }
+    softDeleteProject(db, input.project_id);
+    insertAuditEvent(db, {
+        event_type: 'project_removed',
+        actor: 'loid',
+        summary: `Project ${input.project_id} soft-deleted: ${input.reason}`,
+        detail: JSON.stringify({ project_id: input.project_id, reason: input.reason }),
+    });
+    return { removed: true, message: `Project ${input.project_id} archived` };
+}
+//# sourceMappingURL=project-remove.js.map

package/packages/mcp-tools/dist/layer2/loid/project-upsert.js

@@ -0,0 +1,33 @@
+import { getProject, upsertProject, syncProjectRepos, insertAuditEvent } from '@team-anya/db';
+export async function projectUpsert(db, _workspacePath, input) {
+    const existing = getProject(db, input.project_id);
+    const action = existing ? 'updated' : 'created';
+    upsertProject(db, {
+        project_id: input.project_id,
+        name: input.name,
+        description: input.description ?? null,
+        platform: input.platform ?? 'github',
+        claude_md: input.claude_md ?? null,
+    });
+    const repos = input.repos ?? [];
+    if (repos.length > 0) {
+        syncProjectRepos(db, input.project_id, repos.map(r => ({
+            name: r.name,
+            git_url: r.git_url,
+            repo_path: r.repo_path,
+            default_branch: r.default_branch ?? 'main',
+        })));
+    }
+    insertAuditEvent(db, {
+        event_type: `project_${action}`,
+        actor: 'loid',
+        summary: `Project ${input.project_id} ${action}`,
+        detail: JSON.stringify({
+            project_id: input.project_id,
+            platform: input.platform ?? 'github',
+            repo_count: repos.length,
+        }),
+    });
+    return { project_id: input.project_id, action };
+}
+//# sourceMappingURL=project-upsert.js.map

package/packages/mcp-tools/dist/layer2/loid/task-dispatch.js

@@ -0,0 +1,177 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { execFile as execFileCb } from 'node:child_process';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { createTask, updateTask, insertAuditEvent, getTodayMaxSequence, } from '@team-anya/db';
+import { TaskStatus, generateTaskId, assertTransition } from '@team-anya/core';
+const execFile = promisify(execFileCb);
+/**
+ * 创建任务、写 brief、自动准备工作区
+ *
+ * 派工两步走：task.dispatch(MCP) → yor.spawn(MCP)
+ * dispatch 内部自动根据 project mode 准备隔离工作区（git worktree / mkdir）。
+ * 工作区准备失败时标记 BLOCKED 并返回 error，不抛异常。
+ */
+export async function taskDispatch(deps, input) {
+    const { db, workspacePath, logger } = deps;
+    const seq = getTodayMaxSequence(db) + 1;
+    const taskId = generateTaskId(seq);
+    // 1. 创建任务
+    createTask(db, {
+        task_id: taskId,
+        title: input.title,
+        status: TaskStatus.NEW,
+        source_type: 'feishu',
+        source_ref: input.source_message_id ?? null,
+        objective: input.objective,
+        acceptance_criteria: input.acceptance_criteria ? JSON.stringify(input.acceptance_criteria) : undefined,
+        context: input.context,
+        project_id: input.project_id,
+        created_by: input.created_by ?? null,
+        source_chat_id: input.source_chat_id ?? null,
+    });
+    // 2. 写 brief 到 workspace
+    const taskDir = join(workspacePath, 'yor', 'tasks', taskId);
+    await mkdir(taskDir, { recursive: true });
+    const briefPath = join(taskDir, 'brief.md');
+    await writeFile(briefPath, input.brief, 'utf-8');
+    // 3. 审计日志
+    insertAuditEvent(db, {
+        event_type: 'task_dispatched',
+        actor: 'loid',
+        task_id: taskId,
+        summary: `Loid 派工: ${input.title}`,
+        detail: JSON.stringify({ brief_length: input.brief.length, project: input.project_id }),
+    });
+    // 4. 获取项目配置
+    const project = deps.getProjectConfig
+        ? await deps.getProjectConfig(input.project_id)
+        : undefined;
+    logger?.info(`[anya:pipeline] [Loid] 创建任务 ${taskId} "${input.title}"${input.project_id ? ` | project=${input.project_id} mode=${project?.mode}` : ''}`);
+    // 5. 自动准备工作区
+    const workspaceResult = await prepareWorkspace(taskId, taskDir, project, logger);
+    if (!workspaceResult.ok) {
+        // 工作区准备失败 → NEW → BLOCKED（经状态机校验）
+        assertTransition(TaskStatus.NEW, TaskStatus.BLOCKED);
+        updateTask(db, taskId, { status: TaskStatus.BLOCKED });
+        insertAuditEvent(db, {
+            event_type: 'task_status_changed',
+            actor: 'loid',
+            task_id: taskId,
+            summary: `NEW → BLOCKED: 工作区准备失败: ${workspaceResult.error}`,
+            detail: JSON.stringify({ from: 'NEW', to: 'BLOCKED', reason: workspaceResult.error }),
+        });
+        return { task_id: taskId, status: 'blocked', brief_path: briefPath, error: workspaceResult.error };
+    }
+    // 6. 工作区就绪 → NEW → READY，同时回写工作区信息
+    assertTransition(TaskStatus.NEW, TaskStatus.READY);
+    const branchName = project?.mode === 'project' ? `feat/anya-${taskId}` : undefined;
+    updateTask(db, taskId, {
+        status: TaskStatus.READY,
+        workspace_path: workspaceResult.workingDir,
+        assignee: 'yor',
+        ...(branchName ? { branch: branchName } : {}),
+    });
+    insertAuditEvent(db, {
+        event_type: 'task_status_changed',
+        actor: 'loid',
+        task_id: taskId,
+        summary: 'NEW → READY: 工作区准备完成',
+        detail: JSON.stringify({ from: 'NEW', to: 'READY', workspace_path: workspaceResult.workingDir, branch: branchName }),
+    });
+    return { task_id: taskId, status: 'dispatched', brief_path: briefPath, working_dir: workspaceResult.workingDir };
+}
+async function prepareWorkspace(taskId, taskDir, project, logger) {
+    const mode = project?.mode ?? 'adhoc';
+    try {
+        switch (mode) {
+            case 'project': {
+                const repos = project.repos;
+                const workingDir = taskDir;
+                const createdWorktrees = [];
+                try {
+                    for (const repo of repos) {
+                        const defaultBranch = repo.default_branch ?? 'main';
+                        const wtPath = join(workingDir, repo.name);
+                        await execFile('git', ['-C', repo.repo_path, 'fetch', 'origin']);
+                        await execFile('git', ['-C', repo.repo_path, 'worktree', 'add', wtPath, '-b', `feat/anya-${taskId}`, `origin/${defaultBranch}`]);
+                        createdWorktrees.push({ repoPath: repo.repo_path, wtPath });
+                    }
+                }
+                catch (err) {
+                    // 回滚已创建的 worktree
+                    for (const wt of createdWorktrees) {
+                        try {
+                            await execFile('git', ['-C', wt.repoPath, 'worktree', 'remove', wt.wtPath, '--force']);
+                        }
+                        catch {
+                            // 回滚失败忽略
+                        }
+                    }
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return { ok: false, error: `worktree 准备失败: ${msg}` };
+                }
+                // git init 为 CC 提供项目边界（防止全局搜索）
+                await execFile('git', ['init', workingDir]);
+                // .gitignore 忽略所有 worktree 子目录（它们各自有独立的 .git）
+                const ignoreContent = repos.map(r => `/${r.name}/`).join('\n') + '\n';
+                await writeFile(join(workingDir, '.gitignore'), ignoreContent, 'utf-8');
+                // 写入 CLAUDE.md 帮助 CC 理解工作区结构
+                const claudeMd = buildProjectClaudeMd(taskId, repos, project.claudeMd);
+                await writeFile(join(workingDir, 'CLAUDE.md'), claudeMd, 'utf-8');
+                // 提交到 git，否则 CC 不会加载 untracked 的 CLAUDE.md
+                await execFile('git', ['-C', workingDir, 'add', 'CLAUDE.md', '.gitignore']);
+                await execFile('git', ['-C', workingDir, 'commit', '-m', 'init: workspace config']);
+                logger?.info(`[anya:pipeline] [Loid] worktrees 已创建 (${repos.length} repos): ${workingDir}`);
+                return { ok: true, workingDir };
+            }
+            case 'adhoc':
+            default: {
+                const workingDir = taskDir;
+                await mkdir(join(workingDir, 'adhoc'), { recursive: true });
+                // 在任务级目录 git init，版本管理整个任务目录
+                await execFile('git', ['init', workingDir]);
+                await writeFile(join(workingDir, '.gitignore'), '*.tmp\nnode_modules/\n.DS_Store\n', 'utf-8');
+                await execFile('git', ['-C', workingDir, 'add', '.']);
+                await execFile('git', ['-C', workingDir, 'commit', '-m', `chore: init task ${taskId}`]);
+                logger?.info(`[anya:pipeline] [Loid] adhoc 目录已创建并 git init: ${workingDir}`);
+                return { ok: true, workingDir };
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `工作区准备失败 (${mode}): ${msg}` };
+    }
+}
+// ── 工作区 CLAUDE.md 生成 ──
+function buildProjectClaudeMd(taskId, repos, projectClaudeMd) {
+    const lines = [
+        `# 任务工作区 ${taskId}`,
+        '',
+        '本目录是任务工作区根目录。每个子目录是一个独立的 git worktree。',
+        '',
+        '## 仓库列表',
+        '',
+        '| 目录 | 分支 |',
+        '|------|------|',
+    ];
+    for (const repo of repos) {
+        lines.push(`| \`${repo.name}/\` | \`feat/anya-${taskId}\` (基于 ${repo.default_branch}) |`);
+    }
+    lines.push('');
+    lines.push('## 重要');
+    lines.push('');
+    lines.push('- 每个子目录是独立的 git 仓库（worktree），搜索代码时请进入对应子目录');
+    lines.push('- git 操作（add/commit/push）必须在对应子目录内执行');
+    lines.push('- 不要在根目录执行 git commit');
+    lines.push('- 任务产物请读取 `brief.md` 了解详情');
+    if (projectClaudeMd) {
+        lines.push('');
+        lines.push('## 项目技术栈');
+        lines.push('');
+        lines.push(projectClaudeMd);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=task-dispatch.js.map

package/packages/mcp-tools/dist/layer2/loid/task-lookup.js

@@ -0,0 +1,38 @@
+import { getTask, getTasksByStatus } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+/**
+ * 查询任务状态和历史
+ *
+ * 可按 task_id 或 status 过滤。不传参数时返回所有活跃任务。
+ */
+export async function taskLookup(db, input) {
+    let tasks;
+    if (input.task_id) {
+        const task = getTask(db, input.task_id);
+        tasks = task ? [task] : [];
+    }
+    else if (input.status) {
+        tasks = getTasksByStatus(db, input.status);
+    }
+    else {
+        // 默认返回活跃任务
+        tasks = [
+            ...getTasksByStatus(db, TaskStatus.IN_PROGRESS),
+            ...getTasksByStatus(db, TaskStatus.READY),
+            ...getTasksByStatus(db, TaskStatus.NEED_CLARIFICATION),
+            ...getTasksByStatus(db, TaskStatus.DELIVERING),
+            ...getTasksByStatus(db, TaskStatus.BLOCKED),
+        ];
+    }
+    return {
+        tasks: tasks.map(t => ({
+            task_id: t.task_id,
+            title: t.title,
+            status: t.status,
+            assignee: t.assignee,
+            created_at: t.created_at,
+            pr_url: t.pr_url ?? null,
+        })),
+    };
+}
+//# sourceMappingURL=task-lookup.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-approve.js

@@ -0,0 +1,8 @@
+export function yorApprove(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.approve task=${input.task_id}`);
+    const message = input.message ?? '审核通过，任务完成。你可以做最后的清理工作。';
+    yorOrchestrator.approveAndShutdown(input.task_id, message);
+    return { task_id: input.task_id, approved: true };
+}
+//# sourceMappingURL=yor-approve.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-kill.js

@@ -0,0 +1,7 @@
+export async function yorKill(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.kill task=${input.task_id}`);
+    const result = await yorOrchestrator.kill(input.task_id);
+    return { task_id: input.task_id, killed: result.success };
+}
+//# sourceMappingURL=yor-kill.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-rework.js

@@ -0,0 +1,7 @@
+export function yorRework(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.rework task=${input.task_id}`);
+    yorOrchestrator.sendRework(input.task_id, input.feedback);
+    return { task_id: input.task_id, sent: true };
+}
+//# sourceMappingURL=yor-rework.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-spawn.js

@@ -0,0 +1,15 @@
+export async function yorSpawn(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.spawn ${input.task_id} | dir=${input.working_dir}`);
+    const result = await yorOrchestrator.spawnAndExecute({
+        taskId: input.task_id,
+        workingDir: input.working_dir,
+        briefPath: input.brief_path,
+        env: input.env,
+    });
+    return {
+        instance_id: result.instanceId,
+        task_id: input.task_id,
+    };
+}
+//# sourceMappingURL=yor-spawn.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-status.js

@@ -0,0 +1,8 @@
+export function yorStatus(deps) {
+    const instances = deps.yorOrchestrator.status();
+    return {
+        total: instances.length,
+        instances,
+    };
+}
+//# sourceMappingURL=yor-status.js.map

package/packages/mcp-tools/dist/layer2/yor/task-block.js

@@ -0,0 +1,11 @@
+/**
+ * 报告阻塞
+ *
+ * Yor 遇到无法解决的问题时调用。
+ * 增加 category 字段与 PROTOCOL.md 对齐。
+ */
+export async function taskBlock(collector, input) {
+    collector.onBlockerReport(input);
+    return { received: true, type: 'blocker' };
+}
+//# sourceMappingURL=task-block.js.map

package/packages/mcp-tools/dist/layer2/yor/task-deliver.js

@@ -0,0 +1,35 @@
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(execFileCb);
+/**
+ * 提交交付成果
+ *
+ * Yor 完成任务后调用，报告变更文件、测试结果、PR 链接。
+ * 结果通过 collector 回调传给 dispatcher。
+ *
+ * 交付前检查 git 状态：如果有未提交变更，拒绝交付。
+ */
+export async function taskDeliver(collector, input, workingDir) {
+    // 检查 git 状态
+    if (workingDir) {
+        try {
+            // 检查是否是 git 仓库
+            await execFile('git', ['-C', workingDir, 'rev-parse', '--git-dir']);
+            // 检查是否有未提交变更
+            const { stdout } = await execFile('git', ['-C', workingDir, 'status', '--porcelain']);
+            if (stdout.trim().length > 0) {
+                return {
+                    received: false,
+                    type: 'delivery_rejected',
+                    reason: `❌ 交付被拒绝：工作目录有未提交的变更。\n请先执行 git add + git commit，然后重新调用 task.deliver。\n未提交文件：\n${stdout.trim()}`,
+                };
+            }
+        }
+        catch {
+            // 不是 git 仓库或 git 命令失败，跳过检查（warn 级别）
+        }
+    }
+    collector.onDeliverySubmit(input);
+    return { received: true, type: 'delivery' };
+}
+//# sourceMappingURL=task-deliver.js.map

package/packages/mcp-tools/dist/layer2/yor/task-progress.js

@@ -0,0 +1,21 @@
+import { insertAuditEvent } from '@team-anya/db';
+/**
+ * 中间进度汇报
+ *
+ * 长任务中 Yor 向 Loid 汇报里程碑，不改变任务状态。
+ * 写 audit event（yor_progress），Loid 可通过 audit.query 查看。
+ */
+export async function taskProgress(db, taskId, input) {
+    insertAuditEvent(db, {
+        event_type: 'yor_progress',
+        actor: 'yor',
+        task_id: taskId,
+        summary: input.milestone,
+        detail: JSON.stringify({
+            detail: input.detail,
+            next_step: input.next_step,
+        }),
+    });
+    return { received: true };
+}
+//# sourceMappingURL=task-progress.js.map

package/packages/mcp-tools/dist/layer3/adapters/feishu-adapter.js

@@ -0,0 +1,191 @@
+// ── 媒体类型检测 ──
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.ico', '.tiff', '.tif']);
+const AUDIO_EXTS = new Set(['.opus']);
+const FILE_TYPE_MAP = {
+    '.opus': 'opus', '.mp4': 'mp4', '.pdf': 'pdf',
+    '.doc': 'doc', '.docx': 'doc', '.xls': 'xls', '.xlsx': 'xls',
+    '.ppt': 'ppt', '.pptx': 'ppt',
+};
+/**
+ * 根据文件扩展名检测媒体类型
+ */
+export function detectMediaKind(filePath) {
+    const dot = filePath.lastIndexOf('.');
+    if (dot === -1)
+        return 'file';
+    const ext = filePath.slice(dot).toLowerCase();
+    if (IMAGE_EXTS.has(ext))
+        return 'image';
+    if (AUDIO_EXTS.has(ext))
+        return 'audio';
+    return 'file';
+}
+/**
+ * 根据文件扩展名获取飞书 file_type 参数
+ */
+export function resolveFileType(filePath) {
+    const dot = filePath.lastIndexOf('.');
+    if (dot === -1)
+        return 'stream';
+    const ext = filePath.slice(dot).toLowerCase();
+    return FILE_TYPE_MAP[ext] ?? 'stream';
+}
+// ── Markdown 检测 ──
+/**
+ * 检测文本是否包含 Markdown 语法
+ *
+ * 匹配常见 Markdown 元素：标题、粗体、斜体、代码块、链接、列表、引用、分割线、表格等。
+ * 短文本（<50 字符）且仅含单个 markdown 元素时倾向纯文本，避免误判。
+ */
+const MD_PATTERNS = [
+    /^#{1,6}\s/m, // 标题: # / ## / ###
+    /\*\*[^*]+\*\*/, // 粗体: **text**
+    /\*[^*]+\*/, // 斜体: *text*
+    /`[^`]+`/, // 行内代码: `code`
+    /```[\s\S]*?```/, // 代码块: ```...```
+    /\[.+?\]\(.+?\)/, // 链接: [text](url)
+    /^\s*[-*+]\s/m, // 无序列表: - item / * item
+    /^\s*\d+\.\s/m, // 有序列表: 1. item
+    /^\s*>/m, // 引用: > text
+    /^-{3,}$/m, // 分割线: ---
+    /^\|.+\|$/m, // 表格: | col | col |
+];
+export function isMarkdown(text) {
+    let matchCount = 0;
+    for (const pattern of MD_PATTERNS) {
+        if (pattern.test(text))
+            matchCount++;
+        if (matchCount >= 2)
+            return true;
+    }
+    // 单个匹配：仅当文本较长时才认为是 markdown
+    return matchCount === 1 && text.length >= 80;
+}
+/**
+ * 将 markdown 内容转换为飞书交互式卡片格式
+ */
+function markdownToFeishuCard(content) {
+    return {
+        schema: '2.0',
+        config: { wide_screen_mode: true },
+        body: {
+            elements: [
+                { tag: 'markdown', content },
+            ],
+        },
+    };
+}
+/**
+ * 飞书通道适配器
+ *
+ * 将 FeishuSender 包装为 ChannelAdapter 接口。
+ * target 格式：
+ * - "chat_id" → sendText to chat
+ * - "reply/msg_id" → sendReply（向后兼容）
+ */
+export class FeishuAdapter {
+    scheme = 'feishu';
+    sender;
+    constructor(sender) {
+        this.sender = sender;
+    }
+    /**
+     * 将 mentions 注入到文本中（飞书 @ 格式）
+     */
+    injectMentions(text, mentions) {
+        if (!mentions || mentions.length === 0)
+            return text;
+        const atTags = mentions.map(uid => `<at user_id="${uid}"></at>`).join(' ');
+        return `${atTags} ${text}`;
+    }
+    async send(target, message, options) {
+        const text = this.injectMentions(message, options?.mentions);
+        // 检测是否为 markdown 内容，且 sender 支持卡片发送
+        const useCard = isMarkdown(text) && !!this.sender.sendCard;
+        // 优先使用 options.replyTo
+        const replyTo = options?.replyTo;
+        // 向后兼容：target 以 "reply/" 开头
+        const resolvedReplyTo = replyTo || (target.startsWith('reply/') ? target.slice('reply/'.length) : undefined);
+        const chatTarget = target.startsWith('reply/') ? undefined : target;
+        if (useCard) {
+            const card = markdownToFeishuCard(text);
+            const id = await this.sender.sendCard({
+                receiveIdType: 'chat_id',
+                receiveId: chatTarget ?? '',
+                card,
+                replyToMessageId: resolvedReplyTo,
+            });
+            return { id };
+        }
+        // 纯文本发送
+        if (resolvedReplyTo) {
+            const id = await this.sender.sendReply({
+                text,
+                replyToMessageId: resolvedReplyTo,
+            });
+            return { id };
+        }
+        const id = await this.sender.sendText({
+            receiveIdType: 'chat_id',
+            receiveId: chatTarget ?? target,
+            text,
+        });
+        return { id };
+    }
+    async sendFile(target, file, message, options) {
+        const path = await import('node:path');
+        const fileName = file.fileName || path.basename(file.filePath);
+        // 确定回复目标
+        const replyTo = options?.replyTo || (target.startsWith('reply/') ? target.slice('reply/'.length) : undefined);
+        const chatTarget = target.startsWith('reply/') ? undefined : target;
+        // 自动检测媒体类型
+        const mediaKind = detectMediaKind(file.filePath);
+        let mediaMessageId;
+        if (mediaKind === 'image') {
+            // 图片：走 image.create 上传 → image 消息
+            if (!this.sender.uploadImage || !this.sender.sendImage) {
+                throw new Error('FeishuSender 未实现图片上传能力');
+            }
+            const imageKey = await this.sender.uploadImage(file.filePath);
+            mediaMessageId = await this.sender.sendImage({
+                receiveIdType: 'chat_id',
+                receiveId: chatTarget ?? '',
+                imageKey,
+                replyToMessageId: replyTo,
+            });
+        }
+        else {
+            // 文件/音频：走 file.create 上传 → file/audio 消息
+            if (!this.sender.uploadFile || !this.sender.sendFile) {
+                throw new Error('FeishuSender 未实现文件上传能力');
+            }
+            const fileType = file.fileType || resolveFileType(file.filePath);
+            const fileKey = await this.sender.uploadFile({
+                filePath: file.filePath,
+                fileName,
+                fileType,
+                duration: file.duration,
+            });
+            const msgType = mediaKind === 'audio' ? 'audio' : 'file';
+            mediaMessageId = await this.sender.sendFile({
+                receiveIdType: 'chat_id',
+                receiveId: chatTarget ?? '',
+                fileKey,
+                msgType,
+                replyToMessageId: replyTo,
+            });
+        }
+        // 如果有附带文本，额外发一条文本消息
+        if (message) {
+            const text = this.injectMentions(message, options?.mentions);
+            if (replyTo) {
+                await this.sender.sendReply({ text, replyToMessageId: replyTo });
+            }
+            else if (chatTarget) {
+                await this.sender.sendText({ receiveIdType: 'chat_id', receiveId: chatTarget, text });
+            }
+        }
+        return { id: mediaMessageId };
+    }
+}
+//# sourceMappingURL=feishu-adapter.js.map

package/packages/mcp-tools/dist/layer3/adapters/types.js

@@ -0,0 +1,28 @@
+/**
+ * 通道适配器接口
+ *
+ * 统一飞书/Slack/Web/CLI 等不同通道的消息发送。
+ * channel.send 根据 channel 字段路由到对应 adapter。
+ */
+/**
+ * 通道注册表
+ *
+ * 管理所有已注册的通道适配器。
+ * channel.send 通过 channel 字段查找对应的 adapter。
+ */
+export class ChannelRegistry {
+    adapters = new Map();
+    register(adapter) {
+        this.adapters.set(adapter.scheme, adapter);
+    }
+    get(scheme) {
+        return this.adapters.get(scheme);
+    }
+    has(scheme) {
+        return this.adapters.has(scheme);
+    }
+    getSchemes() {
+        return Array.from(this.adapters.keys());
+    }
+}
+//# sourceMappingURL=types.js.map

package/packages/mcp-tools/dist/layer3/channel-receive.js

@@ -0,0 +1,11 @@
+/**
+ * 拉取新消息（暂不实现）
+ *
+ * 当前消息通过 gateway 推送，Loid 不需要主动拉取。
+ * 保留接口定义，后续版本实现。
+ */
+export async function channelReceive(_input) {
+    // 消息通过 gateway 推送，暂不实现拉取
+    return { messages: [] };
+}
+//# sourceMappingURL=channel-receive.js.map