team-anya 0.2.0

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

@@ -0,0 +1,77 @@
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { updateTask, insertAuditEvent, getTask } from '@team-anya/db';
+const execFile = promisify(execFileCb);
+export async function deliverySubmit(deps, input) {
+    const { db, logger } = deps;
+    // 确定平台：通过任务的 project_id 查项目配置
+    const task = getTask(db, input.task_id);
+    let platform = 'local';
+    if (task?.project_id && deps.getProjectConfig) {
+        const config = await deps.getProjectConfig(task.project_id);
+        platform = config.platform;
+    }
+    logger?.info(`[anya:pipeline] [Loid] delivery.submit ${input.task_id} | platform=${platform} title="${input.title}"`);
+    switch (platform) {
+        case 'github': {
+            const args = ['pr', 'create', '--title', input.title, '--body', input.description];
+            if (input.base_branch) {
+                args.push('--base', input.base_branch);
+            }
+            const { stdout } = await execFile('gh', args, { cwd: input.working_dir });
+            const prUrl = stdout.trim();
+            updateTask(db, input.task_id, { pr_url: prUrl });
+            insertAuditEvent(db, {
+                event_type: 'pr_created',
+                actor: 'loid',
+                task_id: input.task_id,
+                summary: `GitHub PR 已创建: ${input.title}`,
+                detail: JSON.stringify({ pr_url: prUrl, base_branch: input.base_branch, platform }),
+            });
+            return { task_id: input.task_id, pr_url: prUrl, platform };
+        }
+        case 'gitlab': {
+            const args = [
+                'mr', 'create',
+                '--title', input.title,
+                '--description', input.description,
+                '--yes',
+            ];
+            if (input.base_branch) {
+                args.push('--target-branch', input.base_branch);
+            }
+            const { stdout } = await execFile('glab', args, { cwd: input.working_dir });
+            // glab 输出格式：通常包含 MR URL
+            const mrUrl = stdout.trim().split('\n').pop() ?? stdout.trim();
+            updateTask(db, input.task_id, { pr_url: mrUrl });
+            insertAuditEvent(db, {
+                event_type: 'mr_created',
+                actor: 'loid',
+                task_id: input.task_id,
+                summary: `GitLab MR 已创建: ${input.title}`,
+                detail: JSON.stringify({ mr_url: mrUrl, base_branch: input.base_branch, platform }),
+            });
+            return { task_id: input.task_id, pr_url: mrUrl, platform };
+        }
+        case 'local': {
+            // 纯本地任务，记录最终 commit hash
+            let commitHash = 'unknown';
+            try {
+                const { stdout } = await execFile('git', ['-C', input.working_dir, 'log', '-1', '--format=%H']);
+                commitHash = stdout.trim();
+            }
+            catch {
+                // git 命令失败，忽略
+            }
+            insertAuditEvent(db, {
+                event_type: 'delivery_local',
+                actor: 'loid',
+                task_id: input.task_id,
+                summary: `本地交付完成: ${input.title}`,
+                detail: JSON.stringify({ commit_hash: commitHash, platform }),
+            });
+            return { task_id: input.task_id, commit_hash: commitHash, platform };
+        }
+    }
+}
+//# sourceMappingURL=delivery-submit.js.map

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,206 @@
+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 内部通过 WorkspaceManager 创建 clone --local 隔离工作区。
+ * 工作区准备失败时标记 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. 审计日志
+    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 }),
+    });
+    // 3. 获取项目配置
+    const project = deps.getProjectConfig
+        ? await deps.getProjectConfig(input.project_id)
+        : undefined;
+    // 传了 project_id 但未在注册表中找到 → 直接 BLOCKED，不静默降级为 adhoc
+    if (input.project_id && project?.mode === 'adhoc') {
+        // 先写 brief 到旧路径（兼容）
+        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');
+        logger?.info(`[anya:pipeline] [Loid] 创建任务 ${taskId} "${input.title}" | project=${input.project_id} 未注册，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: 项目 "${input.project_id}" 未在注册表中找到，请先通过 project.upsert 注册`,
+            detail: JSON.stringify({ from: 'NEW', to: 'BLOCKED', reason: 'project_not_found', project_id: input.project_id }),
+        });
+        return {
+            task_id: taskId,
+            status: 'blocked',
+            brief_path: briefPath,
+            error: `项目 "${input.project_id}" 未在注册表中找到。请先调用 project.upsert 注册项目及其仓库配置，然后重新派工。`,
+        };
+    }
+    logger?.info(`[anya:pipeline] [Loid] 创建任务 ${taskId} "${input.title}"${input.project_id ? ` | project=${input.project_id} mode=${project?.mode}` : ''}`);
+    // 4. 通过 WorkspaceManager 准备 clone --local 工作区
+    let workspaceResult;
+    let briefPath;
+    workspaceResult = await prepareWorkspaceViaManager(taskId, input.project_id, project, deps.workspaceManager, logger);
+    if (workspaceResult.ok) {
+        briefPath = join(workspaceResult.workingDir, 'brief.md');
+        await writeFile(briefPath, input.brief, 'utf-8');
+    }
+    else {
+        // 工作区创建失败，brief 写到临时目录
+        const taskDir = join(workspacePath, 'yor', 'tasks', taskId);
+        await mkdir(taskDir, { recursive: true });
+        briefPath = join(taskDir, 'brief.md');
+        await writeFile(briefPath, input.brief, 'utf-8');
+    }
+    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 };
+    }
+    // 5. 工作区就绪 → 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 } : {}),
+        ...(workspaceResult.workspaceId ? { workspace_id: workspaceResult.workspaceId } : {}),
+    });
+    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, workspace_id: workspaceResult.workspaceId }),
+    });
+    return { task_id: taskId, status: 'dispatched', brief_path: briefPath, working_dir: workspaceResult.workingDir };
+}
+/**
+ * 通过 WorkspaceManager 创建 clone --local 工作区
+ */
+async function prepareWorkspaceViaManager(taskId, projectId, project, wm, logger) {
+    const mode = project?.mode ?? 'adhoc';
+    try {
+        // 1. 创建工作区
+        const ws = await wm.createWorkspace({
+            role: 'yor',
+            ownerType: 'task',
+            ownerId: taskId,
+            projectId: projectId ?? null,
+        });
+        const workingDir = ws.path;
+        // 2. project mode: 为每个 repo 执行 setupRepo
+        if (mode === 'project' && project?.repos) {
+            const branchName = `feat/anya-${taskId}`;
+            for (const repo of project.repos) {
+                const gitUrl = repo.git_url;
+                if (!gitUrl) {
+                    return { ok: false, error: `仓库 "${repo.name}" 未配置 git_url，无法 clone` };
+                }
+                await wm.setupRepo(ws.id, {
+                    repoName: repo.name,
+                    gitUrl,
+                    baseBranch: repo.default_branch ?? 'main',
+                    taskBranch: branchName,
+                    remoteUrl: gitUrl,
+                });
+            }
+            // git init 根目录（CC 需要 .git 作为项目边界）
+            await execFile('git', ['init', workingDir]);
+            // .gitignore 忽略所有 clone 子目录（它们各自有独立的 .git）
+            const ignoreContent = project.repos.map(r => `/${r.name}/`).join('\n') + '\n';
+            await writeFile(join(workingDir, '.gitignore'), ignoreContent, 'utf-8');
+            // 写入 WORKSPACE-REPOS.md（仓库说明，不覆盖角色 CLAUDE.md）
+            const reposMd = buildWorkspaceReposMd(taskId, project.repos, project.claudeMd);
+            await writeFile(join(workingDir, 'WORKSPACE-REPOS.md'), reposMd, 'utf-8');
+            // 提交到 git
+            await execFile('git', ['-C', workingDir, 'add', 'WORKSPACE-REPOS.md', '.gitignore']);
+            await execFile('git', ['-C', workingDir, 'commit', '-m', 'init: workspace config']);
+            logger?.info(`[anya:pipeline] [Loid] 工作区已创建 (${project.repos.length} repos): ${workingDir}`);
+        }
+        else {
+            // adhoc mode: 只创建工作区，不 setupRepo
+            await mkdir(join(workingDir, 'adhoc'), { recursive: true });
+            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 工作区已创建: ${workingDir}`);
+        }
+        return { ok: true, workingDir, workspaceId: ws.id };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `工作区准备失败 (${mode}): ${msg}` };
+    }
+}
+// ── 工作区 CLAUDE.md 生成 ──
+function buildWorkspaceReposMd(taskId, repos, projectClaudeMd) {
+    const lines = [
+        `# 任务工作区 ${taskId}`,
+        '',
+        '本目录是任务工作区根目录。每个子目录是一个独立的 git clone。',
+        '',
+        '## 仓库列表',
+        '',
+        '| 目录 | 分支 |',
+        '|------|------|',
+    ];
+    for (const repo of repos) {
+        lines.push(`| \`${repo.name}/\` | \`feat/anya-${taskId}\` (基于 ${repo.default_branch}) |`);
+    }
+    lines.push('');
+    lines.push('## 重要');
+    lines.push('');
+    lines.push('- 每个子目录是独立的 git 仓库（clone），搜索代码时请进入对应子目录');
+    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-escalate-to-topic.js

@@ -0,0 +1,170 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getTask, updateTask, generateTopicId, upsertTopic, getProject, insertAuditEvent, } from '@team-anya/db';
+import { TaskStatus, assertTransition } from '@team-anya/core';
+/**
+ * 将已完成的任务升级为话题（Topic），fork 出独立工作区。
+ *
+ * 核心流程：
+ * 1. 校验任务存在且状态为 DONE
+ * 2. 校验任务有 workspace_id（无则建议用 topic.create）
+ * 3. 生成 topic，创建飞书话题（可选）
+ * 4. forkWorkspace：从源工作区 fork 出独立新工作区（franky 角色）
+ * 5. topic 指向新工作区，源工作区保持不变（可审计）
+ * 6. 任务状态 DONE → ESCALATED_TO_TOPIC
+ * 7. 写入 context.md 到新工作区
+ */
+export async function taskEscalateToTopic(deps, input) {
+    const { db, workspaceManager, logger } = deps;
+    // 1. 校验任务
+    const task = getTask(db, input.task_id);
+    if (!task) {
+        throw new Error(`任务 ${input.task_id} 不存在`);
+    }
+    if (task.status !== TaskStatus.DONE) {
+        throw new Error(`任务 ${input.task_id} 状态为 ${task.status}，仅 DONE 状态可升级为话题`);
+    }
+    // 2. 校验 workspace
+    if (!task.workspace_id) {
+        throw new Error(`任务 ${input.task_id} 没有关联工作区（workspace_id），无法升级。请使用 topic.create 创建独立话题。`);
+    }
+    const ws = workspaceManager.getWorkspace(task.workspace_id);
+    if (!ws) {
+        throw new Error(`工作区 ${task.workspace_id} 不存在`);
+    }
+    // 3. 生成 topic ID
+    const topicId = generateTopicId(db);
+    const topicTitle = input.title ?? task.title;
+    const topicDescription = input.description ?? `从任务 ${input.task_id}「${task.title}」升级而来`;
+    // 4. 自动创建飞书话题（复用 topic-create 的逻辑）
+    let threadId = input.thread_id ?? null;
+    let rootMessageId = null;
+    const chatId = input.chat_id ?? task.source_chat_id ?? null;
+    if (!threadId && chatId && deps.threadCreator) {
+        let projectLabel = '';
+        if (task.project_id) {
+            const project = getProject(db, task.project_id);
+            projectLabel = project ? `・${project.name}` : `・${task.project_id}`;
+        }
+        const headerText = `「话题${projectLabel}」${topicTitle}`;
+        rootMessageId = await deps.threadCreator.sendText({
+            receiveIdType: 'chat_id',
+            receiveId: chatId,
+            text: headerText,
+        });
+        const result = await deps.threadCreator.sendReplyInThread({
+            text: `📌 话题已开启（从任务 ${input.task_id} 升级），后续讨论请在此话题内进行。`,
+            replyToMessageId: rootMessageId,
+        });
+        threadId = result.threadId;
+    }
+    // 5. Fork 工作区：从源工作区复制出独立的 franky 工作区
+    const forkedWs = await workspaceManager.forkWorkspace(task.workspace_id, {
+        newRole: 'franky',
+        ownerType: 'topic',
+        ownerId: topicId,
+    });
+    // 6. 写入 topic 记录（指向新的 forked 工作区）
+    upsertTopic(db, {
+        id: topicId,
+        title: topicTitle,
+        description: topicDescription,
+        status: 'active',
+        project_id: task.project_id ?? null,
+        workspace_id: forkedWs.id,
+        workspace_path: forkedWs.path,
+        escalated_from_task_id: input.task_id,
+        thread_id: threadId,
+        root_message_id: rootMessageId,
+        chat_id: chatId,
+        created_by: task.created_by ?? null,
+    });
+    // 7. 任务状态 DONE → ESCALATED_TO_TOPIC（源工作区保持不变，可审计）
+    assertTransition(TaskStatus.DONE, TaskStatus.ESCALATED_TO_TOPIC);
+    updateTask(db, input.task_id, {
+        status: TaskStatus.ESCALATED_TO_TOPIC,
+        escalated_to_topic_id: topicId,
+    });
+    // 8. 写入 context.md 到新工作区
+    const contextContent = buildEscalateContext(input.task_id, task, topicId, topicTitle, topicDescription, chatId, rootMessageId, threadId);
+    await writeFile(join(forkedWs.path, 'context.md'), contextContent, 'utf-8');
+    // 9. 审计日志
+    insertAuditEvent(db, {
+        event_type: 'task_escalated_to_topic',
+        actor: 'loid',
+        task_id: input.task_id,
+        summary: `任务 ${input.task_id} 升级为话题 ${topicId}「${topicTitle}」`,
+        detail: JSON.stringify({
+            task_id: input.task_id,
+            topic_id: topicId,
+            source_workspace_id: task.workspace_id,
+            forked_workspace_id: forkedWs.id,
+            forked_workspace_path: forkedWs.path,
+            thread_id: threadId,
+        }),
+    });
+    logger?.info(`[anya:pipeline] [Loid] 任务 ${input.task_id} 升级为话题 ${topicId}（fork: ${task.workspace_id} → ${forkedWs.id}）`);
+    return {
+        task_id: input.task_id,
+        topic_id: topicId,
+        workspace_path: forkedWs.path,
+        thread_id: threadId,
+    };
+}
+function buildEscalateContext(taskId, task, topicId, topicTitle, topicDescription, chatId, rootMessageId, threadId) {
+    const lines = [
+        `# 话题上下文：${topicTitle} (${topicId})`,
+        '',
+        '## 来源',
+        `从任务 ${taskId}「${task.title}」升级而来。`,
+        '',
+        '## 目标',
+        topicDescription,
+        '',
+    ];
+    if (task.objective) {
+        lines.push('## 原任务目标', task.objective, '');
+    }
+    if (task.acceptance_criteria) {
+        lines.push('## 原验收标准');
+        try {
+            const criteria = JSON.parse(task.acceptance_criteria);
+            if (Array.isArray(criteria)) {
+                for (const c of criteria)
+                    lines.push(`- ${c}`);
+            }
+            else {
+                lines.push(task.acceptance_criteria);
+            }
+        }
+        catch {
+            lines.push(task.acceptance_criteria);
+        }
+        lines.push('');
+    }
+    if (task.context) {
+        lines.push('## 背景信息', task.context, '');
+    }
+    lines.push('## 通讯信息');
+    if (chatId)
+        lines.push(`- 群聊 ID：\`${chatId}\``);
+    if (rootMessageId)
+        lines.push(`- 话题根消息 ID：\`${rootMessageId}\``);
+    if (threadId)
+        lines.push(`- 话题 ID：\`${threadId}\`（仅供参考，channel.send 的 reply_to 请用根消息 ID）`);
+    lines.push('');
+    lines.push('## 项目信息');
+    lines.push(`- 话题 ID：${topicId}`);
+    if (task.project_id)
+        lines.push(`- 关联项目：${task.project_id}`);
+    if (task.branch)
+        lines.push(`- 分支：${task.branch}`);
+    lines.push('');
+    lines.push('## 注意');
+    lines.push('- 本工作区从 Yor 任务工作区 fork 而来，代码 clone 已存在');
+    lines.push('- 请在已有代码基础上继续迭代，不需要重新 clone');
+    lines.push('- 源工作区（Yor）保持不变，仅供审计参考');
+    lines.push('');
+    return lines.join('\n');
+}
+//# sourceMappingURL=task-escalate-to-topic.js.map

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

@@ -0,0 +1,45 @@
+import { getTask, getTasksByStatus, getRecentDoneTasksSince } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+/**
+ * 查询任务状态和历史
+ *
+ * 可按 task_id 或 status 过滤。不传参数时返回所有活跃任务。
+ * mode='recent_done' 时返回最近 30 分钟内完成的任务。
+ */
+export async function taskLookup(db, input) {
+    let tasks;
+    if (input.mode === 'recent_done') {
+        const sinceISO = new Date(Date.now() - 30 * 60 * 1000).toISOString();
+        tasks = getRecentDoneTasksSince(db, sinceISO);
+    }
+    else 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,
+            workspace_id: t.workspace_id ?? null,
+            escalated_to_topic_id: t.escalated_to_topic_id ?? null,
+        })),
+    };
+}
+//# sourceMappingURL=task-lookup.js.map

package/packages/mcp-tools/dist/layer2/loid/topic-close.js

@@ -0,0 +1,22 @@
+import { getTopic, updateTopicStatus, insertAuditEvent, } from '@team-anya/db';
+export async function topicClose(db, input, actor = 'loid') {
+    const topic = getTopic(db, input.topic_id);
+    if (!topic) {
+        return { closed: false, topic_id: input.topic_id, error: `话题 ${input.topic_id} 不存在` };
+    }
+    if (topic.status === 'closed') {
+        return { closed: false, topic_id: input.topic_id, error: `话题已处于 closed 状态` };
+    }
+    updateTopicStatus(db, input.topic_id, 'closed');
+    insertAuditEvent(db, {
+        event_type: 'topic_closed',
+        actor,
+        summary: `关闭话题「${topic.title}」(${input.topic_id})`,
+        detail: JSON.stringify({
+            topic_id: input.topic_id,
+            close_summary: input.summary,
+        }),
+    });
+    return { closed: true, topic_id: input.topic_id };
+}
+//# sourceMappingURL=topic-close.js.map

package/packages/mcp-tools/dist/layer2/loid/topic-create.js

@@ -0,0 +1,60 @@
+import { generateTopicId, upsertTopic, getTopic, getProject, insertAuditEvent, patchMessageLogMetadata, } from '@team-anya/db';
+export async function topicCreate(db, input, threadCreator) {
+    const topicId = generateTopicId(db);
+    let threadId = input.thread_id ?? null;
+    let rootMessageId = null;
+    // 自动创建话题：先发标题消息，再回复开启话题线程
+    if (!threadId && input.chat_id && threadCreator) {
+        // 1. 发送话题标题消息（作为飞书话题根消息）
+        let projectLabel = '';
+        if (input.project_id) {
+            const project = getProject(db, input.project_id);
+            projectLabel = project ? `・${project.name}` : `・${input.project_id}`;
+        }
+        const headerText = `「话题${projectLabel}」${input.title}`;
+        rootMessageId = await threadCreator.sendText({
+            receiveIdType: 'chat_id',
+            receiveId: input.chat_id,
+            text: headerText,
+        });
+        // 2. 回复标题消息，开启话题线程
+        const result = await threadCreator.sendReplyInThread({
+            text: `📌 话题已开启，后续讨论请在此话题内进行。`,
+            replyToMessageId: rootMessageId,
+        });
+        threadId = result.threadId;
+        // 回写 thread_id 到标题消息的 metadata，确保后续以它为 replyTo 的消息能继承 thread_id
+        if (threadId && rootMessageId) {
+            patchMessageLogMetadata(db, rootMessageId, { thread_id: threadId });
+        }
+    }
+    upsertTopic(db, {
+        id: topicId,
+        title: input.title,
+        description: input.description ?? null,
+        status: 'active',
+        project_id: input.project_id ?? null,
+        thread_id: threadId,
+        root_message_id: rootMessageId,
+        chat_id: input.chat_id ?? null,
+        created_by: input.created_by ?? null,
+    });
+    insertAuditEvent(db, {
+        event_type: 'topic_created',
+        actor: 'loid',
+        summary: `创建话题「${input.title}」(${topicId})`,
+        detail: JSON.stringify({
+            topic_id: topicId,
+            project_id: input.project_id,
+            thread_id: threadId,
+        }),
+    });
+    const topic = getTopic(db, topicId);
+    return {
+        topic_id: topic.id,
+        title: topic.title,
+        status: topic.status,
+        thread_id: topic.thread_id,
+    };
+}
+//# sourceMappingURL=topic-create.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