openmatrix 0.1.55 → 0.1.57

package/dist/cli/commands/research.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.researchCommand = void 0;
+// src/cli/commands/research.ts
+const commander_1 = require("commander");
+const gitignore_js_1 = require("../../utils/gitignore.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * 生成并行研究 Agent 配置
+ */
+function generateAgents(topic, domain, aspects) {
+    return [
+        {
+            role: 'domain_researcher',
+            focus: `搜索 ${domain} 领域的核心概念、行业标准、最佳实践。关键词: ${aspects.slice(0, 4).join(', ')}`,
+            status: 'pending'
+        },
+        {
+            role: 'tech_explorer',
+            focus: `搜索 ${domain} 的主流技术方案、开源项目、技术栈选择、架构模式`,
+            status: 'pending'
+        },
+        {
+            role: 'scenario_analyst',
+            focus: `结合用户具体需求 "${topic}"，分析实际应用场景、常见挑战、经验教训`,
+            status: 'pending'
+        }
+    ];
+}
+exports.researchCommand = new commander_1.Command('research')
+    .description('领域调研和问题探索 - 为后续任务提供知识基础')
+    .argument('[topic]', '研究主题')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
+    .option('--confirm', '确认进入深度研究 (从 Skill 传入)')
+    .option('--complete', '标记研究完成，生成报告和任务上下文')
+    .option('--results <json>', '研究结果 JSON (从 Skill 传入)')
+    .action(async (topic, options) => {
+    const basePath = process.cwd();
+    const omPath = path.join(basePath, '.openmatrix');
+    const researchPath = path.join(omPath, 'research');
+    const knowledgePath = path.join(researchPath, 'knowledge');
+    // 确保目录存在
+    await fs.mkdir(omPath, { recursive: true });
+    await fs.mkdir(researchPath, { recursive: true });
+    await fs.mkdir(knowledgePath, { recursive: true });
+    // 确保 .openmatrix 被 git 忽略
+    await (0, gitignore_js_1.ensureOpenmatrixGitignore)(basePath);
+    const sessionPath = path.join(researchPath, 'session.json');
+    // ========== --complete 模式: 研究完成，汇总结果 ==========
+    if (options.complete) {
+        try {
+            const sessionData = await fs.readFile(sessionPath, 'utf-8');
+            const session = JSON.parse(sessionData);
+            // 如果传入了结果，合并
+            if (options.results) {
+                try {
+                    const results = JSON.parse(options.results);
+                    if (results.agents)
+                        session.agents = results.agents;
+                    if (results.report)
+                        session.report = results.report;
+                    if (results.knowledge)
+                        session.knowledge = [...session.knowledge, ...results.knowledge];
+                    if (results.context)
+                        session.context = results.context;
+                    if (results.domainQuestions)
+                        session.domainQuestions = results.domainQuestions;
+                    if (results.answers)
+                        session.answers = { ...session.answers, ...results.answers };
+                }
+                catch {
+                    // 忽略解析错误
+                }
+            }
+            session.status = 'completed';
+            session.completedAt = new Date().toISOString();
+            await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+            // 写入研究报告
+            if (session.report) {
+                await fs.writeFile(path.join(researchPath, 'RESEARCH.md'), session.report, 'utf-8');
+            }
+            // 写入知识条目
+            for (let i = 0; i < session.knowledge.length; i++) {
+                await fs.writeFile(path.join(knowledgePath, `finding-${i + 1}.md`), session.knowledge[i], 'utf-8');
+            }
+            // 写入任务上下文 (供 start 使用)
+            const taskContext = session.context || { goals: [], constraints: [], deliverables: [] };
+            await fs.writeFile(path.join(researchPath, 'context.json'), JSON.stringify({
+                topic: session.topic,
+                domain: session.domain,
+                ...taskContext,
+                reportPath: '.openmatrix/research/RESEARCH.md',
+                knowledgePath: '.openmatrix/research/knowledge/'
+            }, null, 2), 'utf-8');
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'completed',
+                    message: '研究完成',
+                    topic: session.topic,
+                    domain: session.domain,
+                    report: session.report,
+                    knowledge: session.knowledge,
+                    context: taskContext,
+                    reportPath: '.openmatrix/research/RESEARCH.md',
+                    hint: '研究结果已保存，可以使用 /om:start 开始执行任务'
+                }));
+            }
+            else {
+                console.log('研究完成!');
+                console.log(`   主题: ${session.topic}`);
+                console.log(`   领域: ${session.domain}`);
+                console.log(`   知识条目: ${session.knowledge.length} 个`);
+                console.log('\n使用 /om:start 基于研究结果开始任务');
+            }
+            return;
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'error', message: '没有进行中的研究会话' }));
+            }
+            else {
+                console.log('没有进行中的研究会话');
+                console.log('   使用 openmatrix research <topic> 开始新的研究');
+            }
+            return;
+        }
+    }
+    // ========== --confirm 模式: 用户确认后进入深度研究 ==========
+    if (options.confirm) {
+        try {
+            const sessionData = await fs.readFile(sessionPath, 'utf-8');
+            const session = JSON.parse(sessionData);
+            if (session.status !== 'preview') {
+                if (options.json) {
+                    console.log(JSON.stringify({ status: 'error', message: `当前状态为 ${session.status}，无法确认` }));
+                }
+                else {
+                    console.log(`当前状态为 ${session.status}，无法确认`);
+                }
+                return;
+            }
+            // 生成研究 Agent
+            const agents = generateAgents(session.topic, session.domain, session.aspects);
+            session.status = 'researching';
+            session.agents = agents;
+            await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'researching',
+                    message: '开始深度研究',
+                    topic: session.topic,
+                    domain: session.domain,
+                    aspects: session.aspects,
+                    agents: agents.map(a => ({ role: a.role, focus: a.focus, status: a.status })),
+                    hint: '使用 Agent 工具并行执行研究'
+                }));
+            }
+            else {
+                console.log('\n开始深度研究...\n');
+                console.log(`  主题: ${session.topic}`);
+                console.log(`  领域: ${session.domain}`);
+                console.log('\n研究 Agent:');
+                agents.forEach((a, i) => {
+                    console.log(`  ${i + 1}. [${a.role}] ${a.focus}`);
+                });
+            }
+            return;
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'error', message: '没有待确认的研究会话' }));
+            }
+            else {
+                console.log('没有待确认的研究会话');
+            }
+            return;
+        }
+    }
+    // ========== 初始模式: 创建会话，等待 AI 分析 ==========
+    let researchTopic = topic;
+    if (!researchTopic) {
+        const defaultPath = path.join(basePath, 'RESEARCH.md');
+        try {
+            const content = await fs.readFile(defaultPath, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const match = line.match(/^#\s+(.+)$/);
+                if (match) {
+                    researchTopic = match[1].trim();
+                    break;
+                }
+            }
+            if (!researchTopic)
+                researchTopic = content.slice(0, 100).trim();
+            if (!options.json)
+                console.log(`读取研究文件: ${defaultPath}`);
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'error', message: '请提供研究主题' }));
+            }
+            else {
+                console.log('请提供研究主题');
+                console.log('   用法: openmatrix research <topic>');
+                console.log('   或创建 RESEARCH.md 文件');
+            }
+            return;
+        }
+    }
+    // 创建初始会话 - 领域信息由 Agent 分析后更新
+    const session = {
+        status: 'initialized',
+        topic: researchTopic,
+        domain: '',
+        aspects: [],
+        estimatedQuestions: 0,
+        agents: [],
+        domainQuestions: [],
+        answers: {},
+        knowledge: [],
+        createdAt: new Date().toISOString()
+    };
+    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+    if (options.json) {
+        console.log(JSON.stringify({
+            status: 'initialized',
+            message: '研究会话已创建，需要 AI 分析领域',
+            topic: researchTopic,
+            hint: '请使用 Agent 分析主题，识别领域和调研方向，然后更新会话并展示给用户确认'
+        }));
+    }
+    else {
+        console.log(`\n研究主题: ${researchTopic}`);
+        console.log('使用 /om:research 技能启动 AI 分析');
+    }
+});

package/dist/cli/commands/start.js

@@ -164,7 +164,11 @@ async function handleTasksJson(options, stateManager, state, omPath) {
     };
     // 解析质量配置
     const qualityLevel = tasksInput.quality || options.quality || 'balanced';
-    const qualityConfig = index_js_1.QUALITY_PRESETS[qualityLevel.toLowerCase()] || index_js_1.QUALITY_PRESETS.balanced;
+    const qualityConfig = { ...(index_js_1.QUALITY_PRESETS[qualityLevel.toLowerCase()] || index_js_1.QUALITY_PRESETS.balanced) };
+    // E2E 测试覆盖（用户在 Skill 问答中选择启用）
+    if (tasksInput.e2eTests) {
+        qualityConfig.e2eTests = true;
+    }
     if (!options.json) {
         console.log(`\n📋 任务: ${parsedTask.title}`);
         console.log(`   目标: ${parsedTask.goals.join(', ')}`);

package/dist/cli/commands/step.js

@@ -35,68 +35,82 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepCommand = void 0;
 // src/cli/commands/step.ts
+// 循环状态持久化 - 防止上下文压缩导致循环丢失
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
-const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
-const executor_js_1 = require("../../orchestrator/executor.js");
 const path = __importStar(require("path"));
 exports.stepCommand = new commander_1.Command('step')
-    .description('获取下一批可执行任务')
-    .option('--json', 'JSON 输出')
+    .description('获取下一个待执行任务（持久化循环状态）')
+    .option('--json', '输出 JSON 格式')
     .action(async (options) => {
     const basePath = process.cwd();
     const omPath = path.join(basePath, '.openmatrix');
     const stateManager = new state_manager_js_1.StateManager(omPath);
     await stateManager.initialize();
     const state = await stateManager.getState();
-    if (state.status !== 'running') {
-        if (options.json) {
-            console.log(JSON.stringify({
-                status: 'error',
-                message: '没有正在执行的任务',
-                currentState: state.status
-            }));
-        }
-        else {
-            console.log('⚠️  没有正在执行的任务');
-            console.log(`   当前状态: ${state.status}`);
-        }
+    // 检查是否已完成
+    if (state.status === 'completed') {
+        console.log(JSON.stringify({ status: 'done', message: '所有任务已完成' }));
         return;
     }
-    const approvalManager = new approval_manager_js_1.ApprovalManager(stateManager);
-    const executor = new executor_js_1.OrchestratorExecutor(stateManager, approvalManager, {
-        maxConcurrent: state.config.maxConcurrentAgents,
-        taskTimeout: state.config.timeout * 1000
-    });
-    const phaseExecutor = executor.getPhaseExecutor();
-    if (phaseExecutor) {
-        phaseExecutor.setRunId(state.runId);
-    }
-    const result = await executor.step();
-    if (options.json) {
+    // 获取所有任务
+    const allTasks = await stateManager.listTasks();
+    const nextTask = allTasks.find(t => t.status === 'pending' ||
+        t.status === 'scheduled' ||
+        t.status === 'in_progress');
+    if (!nextTask) {
+        // 所有任务都完成了或被阻塞
+        const completed = allTasks.filter(t => t.status === 'completed').length;
+        const total = allTasks.length;
+        // 自动更新统计
+        const stats = {
+            totalTasks: total,
+            completed: completed,
+            inProgress: allTasks.filter(t => t.status === 'in_progress').length,
+            failed: allTasks.filter(t => t.status === 'failed').length,
+            pending: allTasks.filter(t => t.status === 'pending').length
+        };
+        const allDone = completed + stats.failed === total;
+        await stateManager.updateState({
+            statistics: stats,
+            status: allDone ? 'completed' : 'running',
+            currentPhase: allDone ? 'completed' : 'execution'
+        });
         console.log(JSON.stringify({
-            status: result.status,
-            message: result.message,
-            statistics: result.statistics,
-            subagentTasks: result.subagentTasks.map(t => ({
-                subagent_type: t.subagent_type,
-                description: t.description,
-                prompt: t.prompt,
-                isolation: t.isolation,
-                taskId: t.taskId,
-                agentType: t.agentType,
-                timeout: t.timeout
-            }))
+            status: allDone ? 'done' : 'blocked',
+            statistics: stats,
+            message: allDone
+                ? `所有任务已完成 (${completed}/${total})`
+                : `没有可执行任务 (${completed}/${total} 完成, ${stats.failed} 失败, ${stats.pending} 等待)`
         }));
+        return;
     }
-    else {
-        console.log(`状态: ${result.status}`);
-        console.log(`消息: ${result.message}`);
-        if (result.subagentTasks.length > 0) {
-            console.log(`\n📋 待执行任务 (${result.subagentTasks.length}):`);
-            result.subagentTasks.forEach((t, i) => {
-                console.log(`  ${i + 1}. [${t.agentType}] ${t.description.slice(0, 60)}`);
-            });
+    // 输出下一个任务信息
+    const result = {
+        status: 'next',
+        task: {
+            id: nextTask.id,
+            title: nextTask.title,
+            description: nextTask.description,
+            status: nextTask.status,
+            assignedAgent: nextTask.assignedAgent,
+            dependencies: nextTask.dependencies,
+            acceptanceCriteria: nextTask.acceptanceCriteria
+        },
+        statistics: {
+            total: allTasks.length,
+            completed: allTasks.filter(t => t.status === 'completed').length,
+            remaining: allTasks.filter(t => t.status === 'pending' ||
+                t.status === 'scheduled' ||
+                t.status === 'in_progress').length,
+            failed: allTasks.filter(t => t.status === 'failed').length
         }
+    };
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`📌 下一个任务: ${nextTask.id} - ${nextTask.title}`);
+        console.log(`   进度: ${result.statistics.completed}/${result.statistics.total} 完成, ${result.statistics.remaining} 剩余`);
     }
 });

package/dist/cli/index.js

@@ -15,6 +15,9 @@ const check_js_1 = require("./commands/check.js");
 const check_gitignore_js_1 = require("./commands/check-gitignore.js");
 const analyze_js_1 = require("./commands/analyze.js");
 const brainstorm_js_1 = require("./commands/brainstorm.js");
+const research_js_1 = require("./commands/research.js");
+const complete_js_1 = require("./commands/complete.js");
+const step_js_1 = require("./commands/step.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -29,10 +32,13 @@ program.addCommand(retry_js_1.retryCommand);
 program.addCommand(report_js_1.reportCommand);
 program.addCommand(meeting_js_1.meetingCommand);
 program.addCommand(auto_js_1.autoCommand);
+program.addCommand(complete_js_1.completeCommand);
+program.addCommand(step_js_1.stepCommand);
 program.addCommand(install_skills_js_1.installSkillsCommand);
 program.addCommand(check_js_1.checkCommand);
 program.addCommand(check_gitignore_js_1.checkGitignoreCommand);
 program.addCommand(analyze_js_1.analyzeCommand);
 program.addCommand(brainstorm_js_1.brainstormCommand);
+program.addCommand(research_js_1.researchCommand);
 // 默认帮助
 program.parse();

package/dist/orchestrator/phase-executor.js

@@ -702,6 +702,13 @@ ACCEPT_FAILED
                 updates.status = 'completed';
             }
             await this.stateManager.updateTask(task.id, updates);
+            // 持久化 Phase 结果到磁盘
+            await this.stateManager.savePhaseResult(task.id, phase, {
+                success: true,
+                output: result.output,
+                phaseStatus: 'completed',
+                completedAt: now
+            });
             // 自动提交代码
             if (this.runId) {
                 try {
@@ -740,6 +747,13 @@ ACCEPT_FAILED
                 status: 'failed',
                 error: result.error || `${phase} phase failed`
             });
+            // 持久化失败结果
+            await this.stateManager.savePhaseResult(task.id, phase, {
+                success: false,
+                error: result.error || `${phase} phase failed`,
+                phaseStatus: 'failed',
+                failedAt: now
+            });
             return {
                 phase,
                 success: false,

package/dist/storage/state-manager.d.ts

@@ -17,6 +17,22 @@ export declare class StateManager {
     getTask(taskId: string): Promise<Task | null>;
     updateTask(taskId: string, updates: Partial<Task>): Promise<void>;
     listTasks(): Promise<Task[]>;
+    /**
+     * 保存 Phase 结果到任务子目录
+     */
+    savePhaseResult(taskId: string, phase: string, result: Record<string, unknown>): Promise<void>;
+    /**
+     * 读取 Phase 结果
+     */
+    getPhaseResult(taskId: string, phase: string): Promise<Record<string, unknown> | null>;
+    /**
+     * 保存 Agent 上下文到 context.md
+     */
+    saveTaskContext(taskId: string, content: string): Promise<void>;
+    /**
+     * 读取 Agent 上下文
+     */
+    getTaskContext(taskId: string): Promise<string | null>;
     private updateTaskStatistics;
     private generateRunId;
     private generateTaskId;

package/dist/storage/state-manager.js

@@ -74,7 +74,9 @@ class StateManager {
             createdAt: now,
             updatedAt: now
         };
-        await this.store.writeJson(`tasks/${taskId}.json`, task);
+        await this.store.writeJson(`tasks/${taskId}/task.json`, task);
+        // Create artifacts subdirectory
+        await this.store.ensureDir(`tasks/${taskId}/artifacts`);
         // Update statistics
         const state = await this.getState();
         await this.updateState({
@@ -87,7 +89,12 @@ class StateManager {
         return task;
     }
     async getTask(taskId) {
-        return await this.store.readJson(`tasks/${taskId}.json`);
+        // Try subdirectory structure first, fall back to flat file
+        let task = await this.store.readJson(`tasks/${taskId}/task.json`);
+        if (!task) {
+            task = await this.store.readJson(`tasks/${taskId}.json`);
+        }
+        return task;
     }
     async updateTask(taskId, updates) {
         const task = await this.getTask(taskId);
@@ -99,22 +106,67 @@ class StateManager {
             ...updates,
             updatedAt: new Date().toISOString()
         };
-        await this.store.writeJson(`tasks/${taskId}.json`, updatedTask);
+        // Always write to subdirectory structure
+        await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
         // Update statistics if status changed
         if (updates.status && updates.status !== oldStatus) {
             await this.updateTaskStatistics(oldStatus, updates.status);
         }
     }
     async listTasks() {
-        const files = await this.store.listFiles('tasks');
         const tasks = [];
-        for (const file of files) {
-            const task = await this.store.readJson(`tasks/${file}`);
+        // Read from subdirectory structure: tasks/TASK-XXX/task.json
+        const dirs = await this.store.listDirs('tasks');
+        for (const dir of dirs) {
+            const task = await this.store.readJson(`tasks/${dir}/task.json`);
             if (task)
                 tasks.push(task);
         }
+        // Also check flat files (backward compat)
+        const files = await this.store.listFiles('tasks');
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const task = await this.store.readJson(`tasks/${file}`);
+            if (task) {
+                // Avoid duplicate if already found in subdirectory
+                if (!tasks.some(t => t.id === task.id)) {
+                    tasks.push(task);
+                }
+            }
+        }
         return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
     }
+    // ============ Task Artifact Methods ============
+    /**
+     * 保存 Phase 结果到任务子目录
+     */
+    async savePhaseResult(taskId, phase, result) {
+        await this.store.writeJson(`tasks/${taskId}/${phase}.json`, {
+            taskId,
+            phase,
+            timestamp: new Date().toISOString(),
+            ...result
+        });
+    }
+    /**
+     * 读取 Phase 结果
+     */
+    async getPhaseResult(taskId, phase) {
+        return await this.store.readJson(`tasks/${taskId}/${phase}.json`);
+    }
+    /**
+     * 保存 Agent 上下文到 context.md
+     */
+    async saveTaskContext(taskId, content) {
+        await this.store.writeMarkdown(`tasks/${taskId}/context.md`, content);
+    }
+    /**
+     * 读取 Agent 上下文
+     */
+    async getTaskContext(taskId) {
+        return await this.store.readMarkdown(`tasks/${taskId}/context.md`);
+    }
     async updateTaskStatistics(oldStatus, newStatus) {
         const state = await this.getState();
         const stats = { ...state.statistics };

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export type TaskStatus = 'pending' | 'scheduled' | 'in_progress' | 'blocked' | 'waiting' | 'verify' | 'accept' | 'completed' | 'failed' | 'retry_queue';
 export type TaskPriority = 'P0' | 'P1' | 'P2' | 'P3';
+export type ResearchMode = 'domain' | 'tech' | 'problem';
 export interface TaskPhase {
     status: TaskStatus;
     duration: number | null;
@@ -75,7 +76,7 @@ export interface GlobalState {
     version: string;
     runId: string;
     status: RunStatus;
-    currentPhase: 'planning' | 'execution' | 'verification' | 'acceptance';
+    currentPhase: 'planning' | 'execution' | 'verification' | 'acceptance' | 'completed';
     startedAt: string;
     config: AppConfig;
     statistics: {
@@ -201,3 +202,38 @@ export interface ParsedTask {
     deliverables: string[];
     rawContent: string;
 }
+export interface ResearchAgentConfig {
+    role: string;
+    focus: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: string;
+}
+export interface ResearchQuestion {
+    id: string;
+    question: string;
+    header: string;
+    options: Array<{
+        label: string;
+        description: string;
+    }>;
+    multiSelect: boolean;
+}
+export interface ResearchSession {
+    status: 'initialized' | 'preview' | 'researching' | 'questioning' | 'completed';
+    topic: string;
+    domain: string;
+    aspects: string[];
+    estimatedQuestions: number;
+    agents: ResearchAgentConfig[];
+    domainQuestions: ResearchQuestion[];
+    answers: Record<string, string | string[]>;
+    report?: string;
+    knowledge: string[];
+    context?: {
+        goals: string[];
+        constraints: string[];
+        deliverables: string[];
+    };
+    createdAt: string;
+    completedAt?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",