team-anya-cli 0.1.0

package/packages/mcp-tools/dist/registry.js

@@ -0,0 +1,779 @@
+import { z } from 'zod';
+// ── Zod Schemas ──
+// Layer 1: 共享基础 — 新版记忆工具
+export const MemoryRecallInputSchema = z.object({
+    query: z.string().describe('自然语言查询'),
+    scope: z.array(z.string()).optional().describe('限定范围: ["people/wang_lei", "execution"]'),
+    person: z.string().optional().describe('快捷方式: 等价于 scope: ["people/{person}"]'),
+    project: z.string().optional().describe('快捷方式: 等价于 scope: ["projects/{project}"]'),
+    depth: z.enum(['summary', 'full']).optional().describe('返回深度，默认 summary'),
+    limit: z.number().optional().describe('返回条数，默认 5'),
+});
+export const MemoryRememberInputSchema = z.object({
+    category: z.enum(['people', 'project', 'execution', 'commitment', 'self']).describe('记忆类别'),
+    target: z.string().optional().describe('people 时 sender_id, project 时 project_id'),
+    content: z.string().describe('要记住的内容'),
+    sub_type: z.string().optional().describe('子类型: project→pitfall|convention|decision, execution→pattern|failure|tool, self→boundary|mistake|correction'),
+    importance: z.number().optional().describe('重要度 0-1，默认 0.5'),
+    source: z.string().optional().describe('来源 task_id'),
+    expires_at: z.string().optional().describe('过期时间（commitment 用）'),
+});
+export const MemoryDigestInputSchema = z.object({
+    conversation: z.string().describe('对话内容或执行日志'),
+    sender_id: z.string().optional().describe('对话对象 ID'),
+    task_id: z.string().optional().describe('关联任务 ID'),
+    project_id: z.string().optional().describe('关联项目 ID'),
+});
+export const MemoryBriefInputSchema = z.object({
+    sender_id: z.string().optional().describe('正在跟谁沟通'),
+    project_id: z.string().optional().describe('涉及哪个项目'),
+    task_type: z.string().optional().describe('任务类型关键词'),
+    token_budget: z.number().optional().describe('Token 预算，默认 1500'),
+});
+export const MemoryForgetInputSchema = z.object({
+    mode: z.enum(['invalidate']).describe('遗忘模式: invalidate=主动失效'),
+    scope: z.string().optional().describe('失效范围，如 "projects/my-app/pitfalls"'),
+    target: z.string().optional().describe('失效的具体条目内容关键词'),
+    reason: z.string().optional().describe('失效原因'),
+});
+// Layer 1: 共享基础 — 旧版（保留 Schema 定义以便编译兼容，但不再注册到工具表）
+/** @deprecated 使用 MemoryBriefInputSchema */
+export const MemoryContextInputSchema = z.object({
+    scene: z.enum(['task_execution', 'escalation', 'opportunity_eval', 'daily_report']).describe('上下文场景'),
+    vars: z.record(z.string()).describe('场景变量（current_task, current_project 等）'),
+});
+/** @deprecated 使用 MemoryRecallInputSchema */
+export const MemorySearchInputSchema = z.object({
+    query: z.string().describe('搜索关键词'),
+    type: z.string().optional().describe('记忆类型过滤'),
+    tags: z.array(z.string()).optional().describe('标签过滤'),
+    project_id: z.string().optional().describe('项目 ID 过滤'),
+    limit: z.number().optional().describe('返回条数限制（默认 5）'),
+});
+/** @deprecated 使用 MemoryRememberInputSchema */
+export const MemoryLearnInputSchema = z.object({
+    content: z.string().describe('记忆内容'),
+    type: z.string().describe('记忆类型'),
+    tags: z.array(z.string()).describe('标签'),
+    importance: z.number().optional().describe('重要度 0-1，默认 0.5'),
+    task_id: z.string().optional().describe('关联任务 ID'),
+    project_id: z.string().optional().describe('关联项目 ID'),
+    expires_at: z.string().optional().describe('过期时间（ISO 时间戳）'),
+});
+/** @deprecated 使用 MemoryDigestInputSchema */
+export const MemoryReflectInputSchema = z.object({
+    task_id: z.string().optional().describe('限定反思范围的任务 ID'),
+    recent_events: z.string().optional().describe('可选的手动上下文'),
+});
+export const OrgLookupInputSchema = z.object({
+    member_id: z.string().optional().describe('成员 ID'),
+    scope: z.enum(['repo', 'module']).optional().describe('归属范围'),
+    target: z.string().optional().describe('目标（仓库名或模块名）'),
+});
+export const TaskGetInputSchema = z.object({
+    task_id: z.string().describe('任务 ID'),
+});
+export const AuditAppendInputSchema = z.object({
+    event_type: z.string().describe('事件类型'),
+    actor: z.string().describe('操作者'),
+    task_id: z.string().optional().describe('关联任务 ID'),
+    summary: z.string().describe('事件摘要'),
+    detail: z.record(z.unknown()).optional().describe('详细信息'),
+});
+export const AuditQueryInputSchema = z.object({
+    task_id: z.string().optional().describe('按任务 ID 过滤'),
+    event_type: z.string().optional().describe('按事件类型过滤'),
+    actor: z.string().optional().describe('按操作者过滤'),
+    since: z.string().optional().describe('起始时间（ISO 时间戳）'),
+    limit: z.number().optional().describe('返回条数限制（默认 20）'),
+});
+export const ReportDailyInputSchema = z.object({
+    date: z.string().describe('日期（YYYY-MM-DD）'),
+});
+export const TaskUpdateInputSchema = z.object({
+    task_id: z.string().describe('任务 ID'),
+    status: z.string().describe('目标状态（NEW/NEED_CLARIFICATION/READY/IN_PROGRESS/DELIVERING/DONE/BLOCKED/CANCELLED）'),
+    reason: z.string().optional().describe('状态变更原因'),
+});
+// Layer 1: 共享基础 — 项目工具
+export const ProjectListInputSchema = z.object({
+    platform: z.enum(['github', 'gitlab', 'local']).optional().describe('按平台过滤'),
+    include_deleted: z.boolean().optional().describe('是否包含已归档的项目，默认 false'),
+});
+export const ProjectGetInputSchema = z.object({
+    project_id: z.string().describe('项目 ID'),
+});
+// Layer 2: Loid 专属 — 项目管理
+export const ProjectUpsertInputSchema = z.object({
+    project_id: z.string().describe('项目 ID（如 my-app）'),
+    name: z.string().describe('项目显示名称'),
+    description: z.string().optional().describe('项目简介'),
+    platform: z.enum(['github', 'gitlab', 'local']).optional().describe('平台，默认 github'),
+    repos: z.array(z.object({
+        name: z.string().describe('仓库名或子目录名'),
+        git_url: z.string().optional().describe('git 克隆地址'),
+        repo_path: z.string().optional().describe('本地绝对路径'),
+        default_branch: z.string().optional().describe('默认分支，默认 main'),
+    })).optional().describe('仓库列表'),
+    claude_md: z.string().optional().describe('项目级 CLAUDE.md 内容'),
+});
+export const ProjectRemoveInputSchema = z.object({
+    project_id: z.string().describe('要归档的项目 ID'),
+    reason: z.string().describe('归档原因（审计用）'),
+});
+// Layer 2: Loid 专属 - yor.*
+export const YorSpawnInputSchema = z.object({
+    task_id: z.string().describe('任务 ID'),
+    working_dir: z.string().describe('Yor 工作目录'),
+    brief_path: z.string().describe('brief 文件路径'),
+    env: z.record(z.string()).optional().describe('额外环境变量'),
+});
+export const YorKillInputSchema = z.object({
+    task_id: z.string().describe('要终止的 Yor 任务 ID'),
+});
+export const YorStatusInputSchema = z.object({});
+export const YorReworkInputSchema = z.object({
+    task_id: z.string().describe('要返工的 Yor 任务 ID'),
+    feedback: z.string().describe('返工反馈（审核问题 + 修改要求）'),
+});
+export const YorApproveInputSchema = z.object({
+    task_id: z.string().describe('要批准的 Yor 任务 ID'),
+    message: z.string().optional().describe('批准消息（可选，默认 "审核通过"）'),
+});
+// Layer 2: Loid 专属 - delivery.*
+export const DeliverySubmitInputSchema = z.object({
+    task_id: z.string().describe('任务 ID'),
+    title: z.string().describe('PR/MR 标题'),
+    description: z.string().describe('PR/MR 描述'),
+    base_branch: z.string().optional().describe('目标分支（默认由项目配置决定）'),
+    working_dir: z.string().describe('执行命令的工作目录'),
+});
+export const DeliveryUploadInputSchema = z.object({
+    file_path: z.string().describe('要上传的文件路径'),
+    target: z.string().describe('上传目标'),
+});
+export const DeliveryShareInputSchema = z.object({
+    url: z.string().describe('要分享的链接'),
+    target: z.string().describe('分享目标'),
+    message: z.string().describe('分享消息'),
+});
+// Layer 2: Loid 专属
+export const TaskDispatchInputSchema = z.object({
+    title: z.string().describe('任务标题'),
+    brief: z.string().describe('执行 brief（Markdown 格式，只写做什么和标准，不写怎么做）'),
+    project_id: z.string().optional().describe('目标项目/仓库 ID'),
+    objective: z.string().describe('任务目标（一句话概括要达成什么）'),
+    acceptance_criteria: z.array(z.string()).describe('验收标准列表（至少一条可验证的完成条件）'),
+    context: z.string().optional().describe('背景信息（业务上下文、技术约束等）'),
+    conversation_id: z.string().optional().describe('关联的对话 ID'),
+    source_message_id: z.string().optional().describe('触发消息 ID'),
+    created_by: z.string().optional().describe('任务创建者（发起人名字或 ID，从对话上下文中提取）'),
+    source_chat_id: z.string().optional().describe('触发任务的聊天 ID（从对话上下文中提取）'),
+});
+export const TaskLookupInputSchema = z.object({
+    task_id: z.string().optional().describe('指定任务 ID'),
+    status: z.string().optional().describe('按状态过滤'),
+});
+export const DecisionLogInputSchema = z.object({
+    decision: z.string().describe('决策内容'),
+    reasoning: z.string().describe('决策理由'),
+    task_id: z.string().optional().describe('关联任务 ID'),
+});
+// Layer 2: Yor 专属 - 任务状态
+export const TaskDeliverInputSchema = z.object({
+    outcome: z.string().describe('执行结果摘要'),
+    changed_files: z.array(z.string()).describe('变更的文件列表'),
+    test_passed: z.boolean().describe('测试是否全部通过'),
+    test_output: z.string().optional().describe('测试输出摘要'),
+    pr_link: z.string().optional().describe('PR 链接'),
+});
+export const TaskBlockInputSchema = z.object({
+    reason: z.string().describe('阻塞原因'),
+    category: z.enum(['brief_unclear', 'scope_exceeded', 'heal_failed', 'permission', 'refactor_needed']).describe('阻塞分类'),
+    attempted_solutions: z.array(z.string()).describe('已尝试的解决方案'),
+    logs: z.string().optional().describe('相关日志'),
+});
+export const TaskProgressInputSchema = z.object({
+    milestone: z.string().describe('里程碑描述'),
+    detail: z.string().optional().describe('详细说明'),
+    next_step: z.string().optional().describe('下一步计划'),
+});
+// Layer 3: 外部桥梁
+export const ChannelSendInputSchema = z.object({
+    target: z.string().describe('飞书群聊 ID（如 oc_xxx）'),
+    message: z.string().describe('消息内容'),
+    task_id: z.string().optional().describe('关联任务 ID（审计追溯用）'),
+    file: z.object({
+        file_path: z.string().describe('文件路径'),
+        file_name: z.string().optional().describe('自定义文件名'),
+        file_type: z.string().optional().describe('文件类型（opus/mp4/pdf/doc/xls/ppt/stream）'),
+        duration: z.number().optional().describe('音视频时长 ms'),
+    }).optional().describe('发送文件'),
+    mentions: z.array(z.string()).optional().describe('@的用户 ID 列表'),
+    reply_to: z.string().optional().describe('回复的消息 ID'),
+});
+export const FileUploadInputSchema = z.object({
+    file_path: z.string().describe('要上传的文件路径'),
+    file_name: z.string().optional().describe('自定义文件名（默认使用原始文件名）'),
+});
+export const ChannelReceiveInputSchema = z.object({
+    since: z.string().optional().describe('起始时间（ISO 时间戳）'),
+    source: z.string().optional().describe('消息来源过滤'),
+    limit: z.number().optional().describe('返回条数限制'),
+});
+// ── 完整工具注册表 ──
+export const TOOL_REGISTRY = [
+    // Layer 1: 共享基础 — 记忆工具（v2）
+    {
+        name: 'memory.recall',
+        description: '召回记忆。支持按人/项目直读，或自然语言搜索所有记忆目录。',
+        inputSchema: MemoryRecallInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'memory.remember',
+        description: '写入记忆。按类别（people/project/execution/commitment/self）+ 目标写入 YAML 文件。',
+        inputSchema: MemoryRememberInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'memory.digest',
+        description: '消化对话/日志，自动提取记忆。从文本中识别失败/决策/承诺/经验并写入对应记忆目录。',
+        inputSchema: MemoryDigestInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'memory.brief',
+        description: '组装记忆摘要。按优先级（人→项目→执行经验→承诺→自我）在 token 预算内拼装 markdown 摘要。',
+        inputSchema: MemoryBriefInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'memory.forget',
+        description: '遗忘/失效记忆。将指定范围内匹配的记忆条目 heat 设为 0。',
+        inputSchema: MemoryForgetInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'org.lookup',
+        description: '查人员/归属/升级路径。按成员 ID 查身份，按目标查归属权。',
+        inputSchema: OrgLookupInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'task.get',
+        description: '获取任务完整状态。包含任务记录、澄清、承诺、审计事件和文件内容。',
+        inputSchema: TaskGetInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'audit.append',
+        description: '写审计事件。双写 DB + JSONL 文件，保障可回放。',
+        inputSchema: AuditAppendInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'audit.query',
+        description: '查询审计事件。按任务、类型、操作者、时间范围过滤。',
+        inputSchema: AuditQueryInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'report.daily',
+        description: '生成日报。汇总今日完成/进行中/阻塞/承诺/机会。',
+        inputSchema: ReportDailyInputSchema,
+        layer: 1,
+        roles: ['loid'],
+    },
+    {
+        name: 'task.update',
+        description: '原子级任务状态更新。校验状态转换合法性（state machine），同时写 audit log。',
+        inputSchema: TaskUpdateInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    // Layer 1: 共享基础 — 项目工具
+    {
+        name: 'project.list',
+        description: '列出所有已注册项目。可按平台过滤，返回项目概览（不含大字段）。',
+        inputSchema: ProjectListInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'project.get',
+        description: '查询单个项目的完整配置，包括平台、仓库列表、CLAUDE.md 内容。',
+        inputSchema: ProjectGetInputSchema,
+        layer: 1,
+        roles: ['loid', 'yor'],
+    },
+    // Layer 2: Loid 专属 - 项目管理
+    {
+        name: 'project.upsert',
+        description: '创建或更新项目配置。同步仓库列表，写审计日志。',
+        inputSchema: ProjectUpsertInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'project.remove',
+        description: '归档项目（软删除）。需提供归档原因，数据不会真正删除。',
+        inputSchema: ProjectRemoveInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    // Layer 2: Loid 专属 - yor/delivery
+    {
+        name: 'yor.spawn',
+        description: '启动 Yor 执行器进程。指定工作目录和 brief 路径。',
+        inputSchema: YorSpawnInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'yor.kill',
+        description: '终止 Yor 执行器进程。',
+        inputSchema: YorKillInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'yor.status',
+        description: '查询所有 Yor 执行器状态。返回实例列表及运行状态。',
+        inputSchema: YorStatusInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'yor.rework',
+        description: '向运行中的 Yor 发送返工指令。审核交付后发现问题时调用，将反馈注入 Yor CC 让它继续修改。',
+        inputSchema: YorReworkInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'yor.approve',
+        description: '批准 Yor 交付并关闭实例。审核通过后调用，发送确认消息并延迟关闭 Yor CC。',
+        inputSchema: YorApproveInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'delivery.submit',
+        description: '提交交付产物。根据项目平台自动选择：GitHub → PR（gh CLI），GitLab → MR（glab CLI），本地任务 → 记录 commit hash。',
+        inputSchema: DeliverySubmitInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'delivery.upload',
+        description: '上传文件产物（尚未实现）。',
+        inputSchema: DeliveryUploadInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'delivery.share',
+        description: '分享链接/产物（尚未实现）。',
+        inputSchema: DeliveryShareInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    // Layer 2: Loid 专属
+    {
+        name: 'task.dispatch',
+        description: `派工给执行者（Yor）。创建任务、写入 brief、自动准备隔离工作区。
+
+Brief 格式模板：
+\`\`\`markdown
+# {任务标题}
+
+## What
+{一句话说清楚要做什么}
+
+## Why
+{业务背景、为什么要做}
+
+## DoD
+- [ ] {可验证的条件 1}
+- [ ] {可验证的条件 2}
+- [ ] 测试通过 + lint 通过
+
+## Constraints
+- 项目: {project_id}
+- 涉及: {文件/模块范围}
+- 不改: {out-of-scope}
+
+## 执行指引
+{告诉 Yor 怎么交付：Git PR / 文件产物 / 调研报告等}
+- 代码变更 → 引用 execution-guides/git-delivery.md
+- 需要测试 → 引用 execution-guides/testing-and-self-heal.md
+\`\`\`
+
+Brief 只写做什么和标准，不写怎么做。
+
+重要：必须填写 objective（任务目标）和 acceptance_criteria（验收标准），从用户需求中提炼。
+同时从当前对话上下文中提取 created_by（sender_name 或 sender_id）和 source_chat_id（chat_id），确保任务可追溯。
+
+返回值包含 task_id、brief_path 和 working_dir（已准备好的隔离工作区绝对路径）。
+派工两步走：task.dispatch(MCP) → yor.spawn(MCP，传入返回的 working_dir 和 brief_path)。
+如果返回 status="blocked"，说明工作区准备失败，error 字段包含原因，此时不要调用 yor.spawn，应通知人类。`,
+        inputSchema: TaskDispatchInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    // task.review 已移除：Loid 通过 task.update + channel.send 自主决定验收结果
+    {
+        name: 'task.lookup',
+        description: '查询任务列表。可按 task_id 或 status 过滤，不传参数返回所有活跃任务。',
+        inputSchema: TaskLookupInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    {
+        name: 'decision.log',
+        description: '记录决策理由到审计日志。每个重要决策都应记录。',
+        inputSchema: DecisionLogInputSchema,
+        layer: 2,
+        roles: ['loid'],
+    },
+    // Layer 2: Yor 专属 - 任务状态
+    {
+        name: 'task.deliver',
+        description: '提交执行成果。完成任务后调用，报告变更文件、测试结果、PR 链接。',
+        inputSchema: TaskDeliverInputSchema,
+        layer: 2,
+        roles: ['yor'],
+    },
+    {
+        name: 'task.block',
+        description: '报告阻塞。遇到无法解决的问题时调用，说明原因、分类和已尝试的方案。',
+        inputSchema: TaskBlockInputSchema,
+        layer: 2,
+        roles: ['yor'],
+    },
+    {
+        name: 'task.progress',
+        description: '中间进度汇报。长任务中报告里程碑，不改变任务状态。',
+        inputSchema: TaskProgressInputSchema,
+        layer: 2,
+        roles: ['yor'],
+    },
+    // Layer 3: 外部桥梁
+    {
+        name: 'channel.send',
+        description: '向飞书群发消息。target 填群聊 ID。支持发送文件（file）、@用户（mentions）和回复消息（reply_to）。',
+        inputSchema: ChannelSendInputSchema,
+        layer: 3,
+        roles: ['loid', 'yor'],
+    },
+    {
+        name: 'file.upload',
+        description: '通用文件上传（与通道无关）。上传文件到项目存储，返回 URL。当前使用本地存储。',
+        inputSchema: FileUploadInputSchema,
+        layer: 3,
+        roles: ['loid'],
+    },
+    {
+        name: 'channel.receive',
+        description: '拉取新消息（暂不实现，消息通过 gateway 推送）。',
+        inputSchema: ChannelReceiveInputSchema,
+        layer: 3,
+        roles: ['loid'],
+    },
+];
+/**
+ * 按角色获取可用工具列表
+ */
+export function getToolsForRole(role) {
+    return TOOL_REGISTRY.filter(t => t.roles.includes(role));
+}
+/**
+ * 创建工具路由器
+ *
+ * 按角色过滤可用工具，统一路由 MCP 工具调用到对应的实现函数。
+ * Loid/Yor MCP server 只需调用 createToolRouter 即可获得完整工具集。
+ */
+export function createToolRouter(role, deps) {
+    const tools = getToolsForRole(role);
+    const logger = deps.logger ?? { info: console.log, error: console.error };
+    const textResult = (text) => ({
+        content: [{ type: 'text', text }],
+    });
+    /** 按工具名提取关键参数，日志摘要用 */
+    function summarizeArgs(toolName, args) {
+        switch (toolName) {
+            case 'task.dispatch':
+                return `title="${String(args.title ?? '').slice(0, 40)}"`;
+            case 'task.lookup':
+                return args.task_id ? `id=${args.task_id}` : args.status ? `status=${args.status}` : '活跃任务';
+            case 'decision.log':
+                return `"${String(args.decision ?? '').slice(0, 50)}"`;
+            case 'channel.send':
+                return `target=${args.target}${args.file ? ' +file' : ''}`;
+            case 'file.upload':
+                return `file=${args.file_path}`;
+            case 'task.deliver':
+                return `files=${args.changed_files?.length ?? 0} test=${args.test_passed}`;
+            case 'task.block':
+                return `category=${args.category} reason="${String(args.reason ?? '').slice(0, 40)}"`;
+            case 'task.progress':
+                return `"${String(args.milestone ?? '').slice(0, 50)}"`;
+            case 'memory.recall':
+                return `query="${String(args.query ?? '').slice(0, 40)}"${args.person ? ` person=${args.person}` : ''}${args.project ? ` project=${args.project}` : ''}`;
+            case 'memory.remember':
+                return `category=${args.category}${args.target ? '/' + args.target : ''} "${String(args.content ?? '').slice(0, 30)}"`;
+            case 'memory.digest':
+                return `${args.sender_id ? 'sender=' + args.sender_id : ''}${args.task_id ? ' task=' + args.task_id : ''} len=${String(args.conversation ?? '').length}`;
+            case 'memory.brief':
+                return `${args.sender_id ? 'sender=' + args.sender_id : ''}${args.project_id ? ' project=' + args.project_id : ''}`;
+            case 'memory.forget':
+                return `mode=${args.mode} scope=${args.scope ?? 'all'}`;
+            case 'task.update':
+                return `task=${args.task_id} status=${args.status}`;
+            case 'yor.spawn':
+                return `task=${args.task_id} dir=${args.working_dir}`;
+            case 'yor.kill':
+                return `task=${args.task_id}`;
+            case 'yor.status':
+                return '';
+            case 'yor.rework':
+                return `task=${args.task_id} feedback="${String(args.feedback ?? '').slice(0, 40)}"`;
+            case 'yor.approve':
+                return `task=${args.task_id}`;
+            case 'delivery.submit':
+                return `task=${args.task_id} title="${String(args.title ?? '').slice(0, 40)}"`;
+            case 'delivery.upload':
+                return `file=${args.file_path}`;
+            case 'delivery.share':
+                return `url=${args.url}`;
+            case 'project.list':
+                return `${args.platform ? 'platform=' + args.platform : 'all'}${args.include_deleted ? ' +deleted' : ''}`;
+            case 'project.get':
+                return `id=${args.project_id}`;
+            case 'project.upsert':
+                return `id=${args.project_id} name="${String(args.name ?? '').slice(0, 30)}"`;
+            case 'project.remove':
+                return `id=${args.project_id} reason="${String(args.reason ?? '').slice(0, 40)}"`;
+            default:
+                return JSON.stringify(args).slice(0, 80);
+        }
+    }
+    async function handleToolCall(toolName, args) {
+        // 检查工具是否对当前角色可用
+        const toolDef = tools.find(t => t.name === toolName);
+        if (!toolDef) {
+            return textResult(JSON.stringify({ error: `工具 ${toolName} 不可用（角色: ${role}）` }));
+        }
+        const argsSummary = summarizeArgs(toolName, args);
+        logger.info(`[anya:pipeline] [MCP←${role === 'loid' ? 'Loid' : 'Yor'}] ${toolName}(${argsSummary})`);
+        try {
+            const result = await routeToolCall(toolName, args);
+            return textResult(JSON.stringify(result));
+        }
+        catch (err) {
+            logger.error(`[anya:pipeline] ${toolName} 执行失败:`, err);
+            return textResult(JSON.stringify({ error: String(err) }));
+        }
+    }
+    async function routeToolCall(toolName, args) {
+        switch (toolName) {
+            // Layer 1: 共享基础 — 记忆工具（v2）
+            case 'memory.recall': {
+                const { memoryRecall } = await import('./layer1/memory-recall.js');
+                return memoryRecall(deps.workspacePath, args);
+            }
+            case 'memory.remember': {
+                const { memoryRemember } = await import('./layer1/memory-remember.js');
+                return memoryRemember(deps.db, deps.workspacePath, args);
+            }
+            case 'memory.digest': {
+                const { memoryDigest } = await import('./layer1/memory-digest.js');
+                return memoryDigest(deps.db, deps.workspacePath, args);
+            }
+            case 'memory.brief': {
+                const { memoryBrief } = await import('./layer1/memory-brief.js');
+                return memoryBrief(deps.workspacePath, args);
+            }
+            case 'memory.forget': {
+                const { memoryForget } = await import('./layer1/memory-forget.js');
+                return memoryForget(deps.db, deps.workspacePath, args);
+            }
+            case 'org.lookup': {
+                const { orgLookup } = await import('./layer1/org-lookup.js');
+                return orgLookup(deps.db, deps.workspacePath, args);
+            }
+            case 'task.get': {
+                const { taskGet } = await import('./layer1/task-get.js');
+                return taskGet(deps.db, deps.workspacePath, args);
+            }
+            case 'audit.append': {
+                const { auditAppend } = await import('./layer1/audit-append.js');
+                return auditAppend(deps.db, deps.workspacePath, args);
+            }
+            case 'audit.query': {
+                const { auditQuery } = await import('./layer1/audit-query.js');
+                return auditQuery(deps.db, args);
+            }
+            case 'report.daily': {
+                const { reportDaily } = await import('./layer1/report-daily.js');
+                return reportDaily(deps.db, deps.workspacePath, args);
+            }
+            case 'task.update': {
+                const { taskUpdate } = await import('./layer1/task-update.js');
+                return taskUpdate(deps.db, args);
+            }
+            // Layer 1: 共享基础 — 项目工具
+            case 'project.list': {
+                const { projectList } = await import('./layer1/project-list.js');
+                return projectList(deps.db, deps.workspacePath, args);
+            }
+            case 'project.get': {
+                const { projectGet } = await import('./layer1/project-get.js');
+                return projectGet(deps.db, deps.workspacePath, args);
+            }
+            // Layer 2: Loid 专属 - 项目管理
+            case 'project.upsert': {
+                const { projectUpsert } = await import('./layer2/loid/project-upsert.js');
+                return projectUpsert(deps.db, deps.workspacePath, args);
+            }
+            case 'project.remove': {
+                const { projectRemove } = await import('./layer2/loid/project-remove.js');
+                return projectRemove(deps.db, deps.workspacePath, args);
+            }
+            // Layer 2: Loid 专属 - yor/delivery
+            case 'yor.spawn': {
+                const { yorSpawn } = await import('./layer2/loid/yor-spawn.js');
+                if (!deps.yorOrchestrator)
+                    throw new Error('yorOrchestrator 未注入');
+                return yorSpawn({ yorOrchestrator: deps.yorOrchestrator, logger: deps.logger }, args);
+            }
+            case 'yor.kill': {
+                const { yorKill } = await import('./layer2/loid/yor-kill.js');
+                if (!deps.yorOrchestrator)
+                    throw new Error('yorOrchestrator 未注入');
+                return yorKill({ yorOrchestrator: deps.yorOrchestrator, logger: deps.logger }, args);
+            }
+            case 'yor.status': {
+                const { yorStatus } = await import('./layer2/loid/yor-status.js');
+                if (!deps.yorOrchestrator)
+                    throw new Error('yorOrchestrator 未注入');
+                return yorStatus({ yorOrchestrator: deps.yorOrchestrator, logger: deps.logger });
+            }
+            case 'yor.rework': {
+                const { yorRework } = await import('./layer2/loid/yor-rework.js');
+                if (!deps.yorOrchestrator)
+                    throw new Error('yorOrchestrator 未注入');
+                return yorRework({ yorOrchestrator: deps.yorOrchestrator, logger: deps.logger }, args);
+            }
+            case 'yor.approve': {
+                const { yorApprove } = await import('./layer2/loid/yor-approve.js');
+                if (!deps.yorOrchestrator)
+                    throw new Error('yorOrchestrator 未注入');
+                return yorApprove({ yorOrchestrator: deps.yorOrchestrator, logger: deps.logger }, args);
+            }
+            case 'delivery.submit': {
+                const { deliverySubmit } = await import('./layer2/loid/delivery-submit.js');
+                return deliverySubmit({
+                    db: deps.db,
+                    logger: deps.logger,
+                    getProjectConfig: deps.getProjectConfig,
+                }, args);
+            }
+            case 'delivery.upload': {
+                const { deliveryUpload } = await import('./layer2/loid/delivery-upload.js');
+                return deliveryUpload({
+                    db: deps.db,
+                    uploadDir: `${deps.workspacePath}/uploads`,
+                    logger: deps.logger,
+                }, args);
+            }
+            case 'delivery.share': {
+                const { deliveryShare } = await import('./layer2/loid/delivery-share.js');
+                return deliveryShare(args);
+            }
+            // Layer 2: Loid 专属
+            case 'task.dispatch': {
+                const { taskDispatch } = await import('./layer2/loid/task-dispatch.js');
+                return taskDispatch({
+                    db: deps.db,
+                    workspacePath: deps.workspacePath,
+                    logger: deps.logger,
+                    getProjectConfig: deps.getProjectConfig,
+                }, args);
+            }
+            case 'task.lookup': {
+                const { taskLookup } = await import('./layer2/loid/task-lookup.js');
+                return taskLookup(deps.db, args);
+            }
+            case 'decision.log': {
+                const { decisionLog } = await import('./layer2/loid/decision-log.js');
+                return decisionLog(deps.db, args);
+            }
+            // Layer 2: Yor 专属 - 任务状态
+            case 'task.deliver': {
+                const { taskDeliver } = await import('./layer2/yor/task-deliver.js');
+                if (!deps.yorCollector)
+                    throw new Error('yorCollector 未注入');
+                // 获取任务工作目录，用于 git 状态检查
+                let workingDir;
+                if (deps.currentTaskId) {
+                    const { getTask } = await import('@team-anya/db');
+                    const task = getTask(deps.db, deps.currentTaskId);
+                    workingDir = task?.workspace_path ?? undefined;
+                }
+                return taskDeliver(deps.yorCollector, args, workingDir);
+            }
+            case 'task.block': {
+                const { taskBlock } = await import('./layer2/yor/task-block.js');
+                if (!deps.yorCollector)
+                    throw new Error('yorCollector 未注入');
+                return taskBlock(deps.yorCollector, args);
+            }
+            case 'task.progress': {
+                const { taskProgress } = await import('./layer2/yor/task-progress.js');
+                return taskProgress(deps.db, deps.currentTaskId ?? '', args);
+            }
+            // Layer 3: 外部桥梁
+            case 'channel.send': {
+                const { channelSend } = await import('./layer3/channel-send.js');
+                if (!deps.channelRegistry)
+                    throw new Error('channelRegistry 未注入');
+                return channelSend({
+                    db: deps.db,
+                    channelRegistry: deps.channelRegistry,
+                    logger: deps.logger,
+                    onMessageSent: deps.onMessageSent,
+                }, args);
+            }
+            case 'file.upload': {
+                const { fileUpload } = await import('./layer3/file-upload.js');
+                return fileUpload({
+                    db: deps.db,
+                    uploadDir: `${deps.workspacePath}/uploads`,
+                    logger: deps.logger,
+                }, args);
+            }
+            case 'channel.receive': {
+                const { channelReceive } = await import('./layer3/channel-receive.js');
+                return channelReceive(args);
+            }
+            default:
+                throw new Error(`未知工具: ${toolName}`);
+        }
+    }
+    return {
+        tools,
+        handleToolCall,
+    };
+}
+//# sourceMappingURL=registry.js.map