team-anya-cli 0.1.0

package/apps/server/dist/loid/schemas.js

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+// ── Loid 行动工具 Input Schemas ──
+export const DispatchTaskInputSchema = 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('任务创建者（从当前事件的 sender_name 或 sender_id 提取）'),
+    source_chat_id: z.string().optional().describe('触发任务的聊天 ID（从当前对话的 chat_id 提取）'),
+});
+export const AskHumanInputSchema = z.object({
+    message: z.string().describe('要发送给人类的消息内容'),
+    chat_id: z.string().optional().describe('目标群聊 ID'),
+    reply_to_message_id: z.string().optional().describe('回复的消息 ID'),
+    task_id: z.string().optional().describe('关联任务 ID'),
+    intent: z.enum(['clarification', 'report', 'notification']).describe('消息意图'),
+});
+export const ApproveDeliveryInputSchema = z.object({
+    task_id: z.string().describe('要验收的任务 ID'),
+    summary: z.string().optional().describe('验收通过的简评'),
+    notify_human: z.boolean().default(true).describe('是否通知人类'),
+});
+export const RejectDeliveryInputSchema = z.object({
+    task_id: z.string().describe('要打回的任务 ID'),
+    reason: z.string().describe('打回原因'),
+    feedback: z.string().describe('给执行者的修改意见'),
+});
+export const LookupTaskInputSchema = z.object({
+    task_id: z.string().optional().describe('指定任务 ID'),
+    status: z.string().optional().describe('按状态过滤'),
+});
+export const LogDecisionInputSchema = z.object({
+    decision: z.string().describe('决策内容'),
+    reasoning: z.string().describe('决策理由'),
+    task_id: z.string().optional().describe('关联任务 ID'),
+});
+export const NoActionInputSchema = z.object({
+    reason: z.string().describe('不处理的原因'),
+});
+// ── Output Schemas（工具执行后返回给 Loid 的结果）──
+export const DispatchTaskOutputSchema = z.object({
+    task_id: z.string(),
+    status: z.literal('dispatched'),
+});
+export const AskHumanOutputSchema = z.object({
+    sent: z.boolean(),
+    message_id: z.string().optional(),
+});
+export const ApproveDeliveryOutputSchema = z.object({
+    approved: z.boolean(),
+    task_id: z.string(),
+});
+export const RejectDeliveryOutputSchema = z.object({
+    rejected: z.boolean(),
+    task_id: z.string(),
+    retry_count: z.number(),
+    max_retries: z.number(),
+});
+export const LookupTaskOutputSchema = z.object({
+    tasks: z.array(z.object({
+        task_id: z.string(),
+        title: z.string(),
+        status: z.string(),
+        assignee: z.string().nullable(),
+        created_at: z.string().nullable(),
+        pr_url: z.string().nullable().optional(),
+    })),
+});
+export const LogDecisionOutputSchema = z.object({
+    logged: z.boolean(),
+});
+export const NoActionOutputSchema = z.object({
+    acknowledged: z.boolean(),
+});
+// ── Tool 注册表 ──
+export const LOID_TOOL_REGISTRY = {
+    dispatch_task: {
+        description: '派工给执行者（Yor）。创建任务、写入 brief、启动执行。',
+        inputSchema: DispatchTaskInputSchema,
+        outputSchema: DispatchTaskOutputSchema,
+    },
+    ask_human: {
+        description: '向人类发送消息（提问、汇报结果、通知）。',
+        inputSchema: AskHumanInputSchema,
+        outputSchema: AskHumanOutputSchema,
+    },
+    approve_delivery: {
+        description: '验收通过执行者的交付成果。标记任务完成，可选通知人类。',
+        inputSchema: ApproveDeliveryInputSchema,
+        outputSchema: ApproveDeliveryOutputSchema,
+    },
+    reject_delivery: {
+        description: '打回执行者的交付，附带修改意见并重新派工。最多返工 3 次。',
+        inputSchema: RejectDeliveryInputSchema,
+        outputSchema: RejectDeliveryOutputSchema,
+    },
+    lookup_task: {
+        description: '查询任务状态和历史。可按 task_id 或 status 过滤。',
+        inputSchema: LookupTaskInputSchema,
+        outputSchema: LookupTaskOutputSchema,
+    },
+    log_decision: {
+        description: '记录决策理由到审计日志。',
+        inputSchema: LogDecisionInputSchema,
+        outputSchema: LogDecisionOutputSchema,
+    },
+    no_action: {
+        description: '明确表示不处理此消息。记录原因到日志。',
+        inputSchema: NoActionInputSchema,
+        outputSchema: NoActionOutputSchema,
+    },
+};
+//# sourceMappingURL=schemas.js.map

package/apps/server/dist/loid/self-calibrator.js

@@ -0,0 +1,314 @@
+/**
+ * SelfCalibrator - 自我校准模块
+ *
+ * 从执行结果中自动校准能力评估：
+ * - 统计成功率（按项目/类型分组）
+ * - 识别常见失败模式
+ * - 计算自愈成功率
+ * - 更新 capability-notes.md
+ * - 提供项目风险提示
+ */
+import { getAllTasks, getAuditEventsByType, insertAuditEvent } from '@team-anya/db';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+// ── 终态状态集 ──
+const TERMINAL_STATUSES = new Set(['DONE', 'CANCELLED']);
+const SUCCESS_STATUSES = new Set(['DONE']);
+// ── 实现 ──
+export class SelfCalibrator {
+    db;
+    workspacePath;
+    _lastStatus = {
+        lastCalibratedAt: null,
+        report: null,
+        deviationFactors: null,
+        warnings: [],
+    };
+    constructor(opts) {
+        this.db = opts.db;
+        this.workspacePath = opts.workspacePath;
+    }
+    /**
+     * 计算执行统计数据
+     */
+    computeStats() {
+        const allTasks = getAllTasks(this.db);
+        const terminalTasks = allTasks.filter(t => TERMINAL_STATUSES.has(t.status));
+        const successTasks = terminalTasks.filter(t => SUCCESS_STATUSES.has(t.status));
+        const totalCompleted = terminalTasks.length;
+        const successCount = successTasks.length;
+        const successRate = totalCompleted > 0 ? successCount / totalCompleted : 0;
+        // 平均重试次数
+        const avgRetryCount = totalCompleted > 0
+            ? terminalTasks.reduce((sum, t) => sum + (t.retry_count ?? 0), 0) / totalCompleted
+            : 0;
+        // 按项目分组
+        const byProject = {};
+        for (const task of terminalTasks) {
+            const pid = task.project_id;
+            if (!pid)
+                continue;
+            if (!byProject[pid]) {
+                byProject[pid] = { total: 0, success: 0, successRate: 0 };
+            }
+            byProject[pid].total++;
+            if (SUCCESS_STATUSES.has(task.status)) {
+                byProject[pid].success++;
+            }
+        }
+        for (const group of Object.values(byProject)) {
+            group.successRate = group.total > 0 ? group.success / group.total : 0;
+        }
+        // 按 source_type 分组
+        const bySourceType = {};
+        for (const task of terminalTasks) {
+            const st = task.source_type;
+            if (!bySourceType[st]) {
+                bySourceType[st] = { total: 0, success: 0, successRate: 0 };
+            }
+            bySourceType[st].total++;
+            if (SUCCESS_STATUSES.has(task.status)) {
+                bySourceType[st].success++;
+            }
+        }
+        for (const group of Object.values(bySourceType)) {
+            group.successRate = group.total > 0 ? group.success / group.total : 0;
+        }
+        return { totalCompleted, successCount, successRate, avgRetryCount, byProject, bySourceType };
+    }
+    /**
+     * 分析失败模式（从 task_blocked 审计事件中提取）
+     */
+    analyzeFailurePatterns() {
+        const blockedEvents = getAuditEventsByType(this.db, 'task_blocked');
+        const patternMap = new Map();
+        for (const event of blockedEvents) {
+            if (!event.detail)
+                continue;
+            try {
+                const detail = JSON.parse(event.detail);
+                const reason = detail.reason;
+                if (!reason)
+                    continue;
+                const existing = patternMap.get(reason);
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    patternMap.set(reason, { count: 1, type: detail.type });
+                }
+            }
+            catch {
+                // detail 不是有效 JSON，跳过
+            }
+        }
+        const patterns = [];
+        for (const [pattern, data] of patternMap) {
+            patterns.push({ pattern, count: data.count, type: data.type });
+        }
+        // 按出现次数降序排列
+        patterns.sort((a, b) => b.count - a.count);
+        return patterns;
+    }
+    /**
+     * 计算自愈成功率
+     */
+    computeSelfHealRate() {
+        const healEvents = getAuditEventsByType(this.db, 'self_heal_attempt');
+        if (healEvents.length === 0) {
+            return { total: 0, succeeded: 0, rate: 0 };
+        }
+        let succeeded = 0;
+        for (const event of healEvents) {
+            if (!event.detail)
+                continue;
+            try {
+                const detail = JSON.parse(event.detail);
+                if (detail.success)
+                    succeeded++;
+            }
+            catch {
+                // 跳过
+            }
+        }
+        return {
+            total: healEvents.length,
+            succeeded,
+            rate: healEvents.length > 0 ? succeeded / healEvents.length : 0,
+        };
+    }
+    /**
+     * 生成完整的校准报告
+     */
+    generateReport() {
+        return {
+            stats: this.computeStats(),
+            failurePatterns: this.analyzeFailurePatterns(),
+            selfHealRate: this.computeSelfHealRate(),
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * 更新 capability-notes.md 文件
+     */
+    async updateCapabilityNotes() {
+        const report = this.generateReport();
+        const content = this.formatCapabilityNotes(report);
+        const notesPath = join(this.workspacePath, 'memory', 'self', 'capability-notes.md');
+        await writeFile(notesPath, content, 'utf-8');
+    }
+    /**
+     * 获取指定项目的风险提示
+     */
+    getRiskHints(projectId) {
+        const stats = this.computeStats();
+        const projectStats = stats.byProject[projectId];
+        const hints = [];
+        if (!projectStats)
+            return hints;
+        // 低成功率警告（< 50%）
+        if (projectStats.successRate < 0.5) {
+            hints.push(`该项目成功率偏低 (${(projectStats.successRate * 100).toFixed(0)}%)，建议关注失败原因`);
+        }
+        // 高重试率警告（平均重试 >= 2）
+        const projectTasks = getAllTasks(this.db).filter(t => t.project_id === projectId && TERMINAL_STATUSES.has(t.status));
+        if (projectTasks.length > 0) {
+            const avgRetry = projectTasks.reduce((sum, t) => sum + (t.retry_count ?? 0), 0) / projectTasks.length;
+            if (avgRetry >= 2) {
+                hints.push(`该项目平均重试次数较高 (${avgRetry.toFixed(1)}次)，可能存在系统性问题`);
+            }
+        }
+        return hints;
+    }
+    /**
+     * 计算偏差校正因子
+     */
+    computeDeviationFactors() {
+        const allTasks = getAllTasks(this.db);
+        const terminalTasks = allTasks.filter(t => TERMINAL_STATUSES.has(t.status));
+        // 重试偏差：平均 retry_count / max_retries
+        let retryDeviation = 0;
+        if (terminalTasks.length > 0) {
+            const ratios = terminalTasks.map(t => {
+                const maxRetries = t.max_retries ?? 3;
+                if (maxRetries === 0)
+                    return 0;
+                return (t.retry_count ?? 0) / maxRetries;
+            });
+            retryDeviation = ratios.reduce((a, b) => a + b, 0) / ratios.length;
+        }
+        // 承诺达成率
+        const fulfilledEvents = getAuditEventsByType(this.db, 'commitment_fulfilled');
+        const brokenEvents = getAuditEventsByType(this.db, 'commitment_broken');
+        const totalCommitmentEvents = fulfilledEvents.length + brokenEvents.length;
+        const commitmentFulfillRate = totalCommitmentEvents > 0
+            ? fulfilledEvents.length / totalCommitmentEvents
+            : 0;
+        // 校正因子：retryDeviation 越高说明低估复杂度
+        // 0 偏差 → 1.0（无需校正），1.0 偏差 → 1.5（需要 50% 更多缓冲）
+        const correctionFactor = terminalTasks.length > 0
+            ? 1.0 + retryDeviation * 0.5
+            : 1.0;
+        return { retryDeviation, commitmentFulfillRate, correctionFactor };
+    }
+    /**
+     * 执行一次完整校准，记录审计事件并缓存状态
+     */
+    runCalibration() {
+        const report = this.generateReport();
+        const deviationFactors = this.computeDeviationFactors();
+        const now = new Date().toISOString();
+        // 生成偏差警告
+        const warnings = [];
+        const RETRY_DEVIATION_THRESHOLD = 0.7;
+        if (deviationFactors.retryDeviation >= RETRY_DEVIATION_THRESHOLD) {
+            warnings.push(`重试偏差过高 (${(deviationFactors.retryDeviation * 100).toFixed(0)}%)，建议调整复杂度预估`);
+        }
+        if (report.stats.successRate < 0.5 && report.stats.totalCompleted > 0) {
+            warnings.push(`整体成功率偏低 (${(report.stats.successRate * 100).toFixed(0)}%)，需要关注系统性问题`);
+        }
+        // 记录审计事件
+        insertAuditEvent(this.db, {
+            event_type: 'calibration',
+            actor: 'loid',
+            summary: `自我校准完成: 成功率 ${(report.stats.successRate * 100).toFixed(1)}%, 校正因子 ${deviationFactors.correctionFactor.toFixed(2)}`,
+            detail: JSON.stringify({
+                stats: report.stats,
+                deviationFactors,
+                warnings,
+            }),
+        });
+        // 缓存状态
+        this._lastStatus = {
+            lastCalibratedAt: now,
+            report,
+            deviationFactors,
+            warnings,
+        };
+        return this._lastStatus;
+    }
+    /**
+     * 获取当前校准状态（返回上次 runCalibration 的缓存）
+     */
+    getCalibrationStatus() {
+        return this._lastStatus;
+    }
+    // ── 私有方法 ──
+    formatCapabilityNotes(report) {
+        const { stats, failurePatterns, selfHealRate } = report;
+        if (stats.totalCompleted === 0 && failurePatterns.length === 0 && selfHealRate.total === 0) {
+            return `# Anya Capability Notes\n\n> 自动生成于 ${report.generatedAt}\n\n无数据 — 尚无已完成的任务记录。\n`;
+        }
+        const lines = [
+            '# Anya Capability Notes',
+            '',
+            `> 自动生成于 ${report.generatedAt}`,
+            '',
+            '## 执行统计',
+            '',
+            `- 已完成任务: ${stats.totalCompleted}`,
+            `- 成功数: ${stats.successCount}`,
+            `- 整体成功率: ${(stats.successRate * 100).toFixed(1)}%`,
+            `- 平均重试次数: ${stats.avgRetryCount.toFixed(1)}`,
+            '',
+        ];
+        // 项目分组统计
+        const projectIds = Object.keys(stats.byProject);
+        if (projectIds.length > 0) {
+            lines.push('### 按项目', '');
+            for (const pid of projectIds) {
+                const g = stats.byProject[pid];
+                lines.push(`- **${pid}**: ${g.success}/${g.total} (成功率 ${(g.successRate * 100).toFixed(1)}%)`);
+            }
+            lines.push('');
+        }
+        // source_type 分组统计
+        const sourceTypes = Object.keys(stats.bySourceType);
+        if (sourceTypes.length > 0) {
+            lines.push('### 按来源类型', '');
+            for (const st of sourceTypes) {
+                const g = stats.bySourceType[st];
+                lines.push(`- **${st}**: ${g.success}/${g.total} (成功率 ${(g.successRate * 100).toFixed(1)}%)`);
+            }
+            lines.push('');
+        }
+        // 失败模式
+        if (failurePatterns.length > 0) {
+            lines.push('## 失败模式', '');
+            for (const p of failurePatterns) {
+                lines.push(`- **${p.pattern}**: ${p.count}次${p.type ? ` (类型: ${p.type})` : ''}`);
+            }
+            lines.push('');
+        }
+        // 自愈成功率
+        if (selfHealRate.total > 0) {
+            lines.push('## 自愈能力', '');
+            lines.push(`- 自愈尝试: ${selfHealRate.total}次`);
+            lines.push(`- 自愈成功: ${selfHealRate.succeeded}次`);
+            lines.push(`- 自愈成功率: ${(selfHealRate.rate * 100).toFixed(1)}%`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=self-calibrator.js.map

package/apps/server/dist/loid/session-manager.js

@@ -0,0 +1,217 @@
+import { join } from 'node:path';
+import { getTasksByStatus } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+import { LoidSession, } from './session.js';
+import { formatMessageContextPrompt, formatFollowUpPrompt, formatDeliveryContextPrompt, formatRecoveryPrompt, } from './context-builder.js';
+// ── LoidSessionManager ──
+export class LoidSessionManager {
+    sessions = new Map();
+    config;
+    deps;
+    logger;
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+    }
+    // ── 公开方法 ──
+    /**
+     * 处理新消息：有活跃 session 就 enqueue，没有就创建
+     */
+    async handleMessage(chatId, ctx) {
+        const key = chatId;
+        const existing = this.sessions.get(key);
+        if (existing) {
+            const state = existing.getState();
+            if (state !== 'disposed') {
+                const prompt = formatFollowUpPrompt(ctx);
+                existing.enqueue({ type: 'message', prompt, enqueuedAt: new Date() });
+                return;
+            }
+            // session 已销毁，删除并新建
+            this.sessions.delete(key);
+        }
+        // 新建 session
+        const session = await this.createSession(key);
+        const contextPrompt = formatMessageContextPrompt(ctx);
+        session.enqueue({ type: 'message', prompt: contextPrompt, enqueuedAt: new Date() });
+    }
+    /**
+     * 处理 Yor 交付验收：查找来源 session，活着就复用，否则新建
+     */
+    async handleDelivery(ctx) {
+        const sourceChatId = ctx.sourceChatId;
+        // 尝试复用来源 session
+        if (sourceChatId && this.sessions.has(sourceChatId)) {
+            const session = this.sessions.get(sourceChatId);
+            const state = session.getState();
+            if (state !== 'disposed') {
+                const prompt = formatDeliveryContextPrompt(ctx);
+                session.enqueue({ type: 'delivery', prompt, enqueuedAt: new Date() });
+                return;
+            }
+            this.sessions.delete(sourceChatId);
+        }
+        // 来源 session 已回收，新建独立 session
+        const key = `delivery:${ctx.taskId}`;
+        const session = await this.createSession(key);
+        const protocol = this.config.protocols['review'] ?? '';
+        const prompt = [
+            protocol ? protocol + '\n\n---\n\n' : '',
+            formatDeliveryContextPrompt(ctx),
+        ].join('');
+        session.enqueue({ type: 'delivery', prompt, enqueuedAt: new Date() });
+    }
+    /**
+     * 获取当前活跃 session 数量
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * 获取指定 session 的状态（用于诊断）
+     */
+    getSessionState(key) {
+        return this.sessions.get(key)?.getState() ?? null;
+    }
+    /**
+     * 关闭所有 session，释放资源
+     */
+    async dispose() {
+        const disposePromises = [];
+        for (const [key, session] of this.sessions) {
+            this.logger.info(`[SessionManager] 正在关闭 session: ${key}`);
+            disposePromises.push(session.dispose());
+        }
+        await Promise.all(disposePromises);
+        this.sessions.clear();
+        this.logger.info('[SessionManager] 所有 session 已关闭');
+    }
+    // ── 私有方法 ──
+    /**
+     * 创建新 LoidSession，注册生命周期回调
+     * 如果 broker 槽位满，尝试 LRU 淘汰后重试
+     */
+    async createSession(key) {
+        this.logger.info(`[SessionManager] 创建新 session: ${key}`);
+        const instanceId = `loid:${key}`;
+        const logFile = this.config.logDir
+            ? join(this.config.logDir, `loid-${key.replace(/[/:]/g, '_')}-${Date.now()}.log`)
+            : undefined;
+        const sessionConfig = {
+            broker: this.config.broker,
+            instanceId,
+            backendConfig: this.config.backendConfig,
+            idleTimeoutMs: this.config.idleTimeoutMs,
+            maxTurns: this.config.maxTurnsPerSession,
+            logFile,
+            db: this.deps.db,
+            chatId: key,
+            logger: this.logger,
+        };
+        const session = new LoidSession(sessionConfig, {
+            onCrash: (orphanMessages) => {
+                this.onSessionCrash(key, orphanMessages);
+            },
+            onDisposed: () => {
+                this.logger.info(`[SessionManager] session 自然结束: ${key}`);
+                this.sessions.delete(key);
+            },
+        });
+        try {
+            await session.connect();
+        }
+        catch (err) {
+            // 槽位满时尝试 LRU 淘汰
+            if (err instanceof Error && err.message.includes('实例已满')) {
+                const evicted = await this.evictLRU();
+                if (evicted) {
+                    this.logger.info(`[SessionManager] LRU 淘汰 ${evicted}，重试创建 ${key}`);
+                    await session.connect();
+                }
+                else {
+                    throw err;
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+        this.sessions.set(key, session);
+        return session;
+    }
+    /**
+     * LRU 淘汰：找到最久没活动且处于 IDLE 的 session，dispose 它
+     * 返回被淘汰的 session key，无可淘汰时返回 null
+     */
+    async evictLRU() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, session] of this.sessions) {
+            if (session.getState() === 'idle') {
+                const activityTime = session.getLastActivityAt().getTime();
+                if (activityTime < oldestTime) {
+                    oldestTime = activityTime;
+                    oldestKey = key;
+                }
+            }
+        }
+        if (oldestKey) {
+            const session = this.sessions.get(oldestKey);
+            await session.dispose();
+            this.sessions.delete(oldestKey);
+            this.logger.info(`[SessionManager] LRU 淘汰 session: ${oldestKey}`);
+            return oldestKey;
+        }
+        return null;
+    }
+    /**
+     * Session 崩溃恢复：删旧 session，新建处理孤儿消息
+     */
+    async onSessionCrash(key, orphanedMessages) {
+        this.logger.error(`[SessionManager] session 崩溃: ${key} (${orphanedMessages.length} 条孤儿消息)`);
+        // 删除旧 session
+        this.sessions.delete(key);
+        // 从 DB 加载活跃任务状态作为恢复上下文
+        const activeTasks = this.getActiveTasks();
+        const recoveryPrompt = formatRecoveryPrompt(activeTasks);
+        try {
+            const newSession = await this.createSession(key);
+            // 先投递恢复上下文
+            newSession.enqueue({ type: 'recovery', prompt: recoveryPrompt, enqueuedAt: new Date() });
+            // 再投递孤儿消息
+            for (const msg of orphanedMessages) {
+                newSession.enqueue(msg);
+            }
+        }
+        catch (err) {
+            this.logger.error(`[SessionManager] 崩溃恢复失败 (${key}):`, err);
+        }
+    }
+    /**
+     * 获取活跃任务列表（用于崩溃恢复上下文）
+     */
+    getActiveTasks() {
+        const statuses = [
+            TaskStatus.IN_PROGRESS,
+            TaskStatus.READY,
+            TaskStatus.NEED_CLARIFICATION,
+            TaskStatus.DELIVERING,
+            TaskStatus.BLOCKED,
+        ];
+        const tasks = [];
+        for (const status of statuses) {
+            const statusTasks = getTasksByStatus(this.deps.db, status);
+            for (const t of statusTasks) {
+                tasks.push({
+                    task_id: t.task_id,
+                    title: t.title,
+                    status: t.status,
+                    assignee: t.assignee,
+                });
+            }
+        }
+        return tasks;
+    }
+}
+//# sourceMappingURL=session-manager.js.map