openmatrix 0.1.49 → 0.1.51

package/dist/orchestrator/task-planner.js

@@ -4,41 +4,48 @@ exports.TaskPlanner = void 0;
 /**
  * TaskPlanner - 任务拆解器
  *
- * 1. 按 goals 拆分为多个 coder + tester 任务对
- * 2. goals 为空时退化为 3 任务模式 (planner → coder → tester)
- * 3. 自动注入用户上下文和验收标准
+ * 增强版特性:
+ * 1. 更细粒度的任务拆分 (每个目标拆分为设计+实现+测试)
+ * 2. 测试任务配对 (每个开发任务自动生成对应测试任务)
+ * 3. 验收标准注入 (从用户回答中提取)
+ * 4. 用户上下文注入 (将用户回答注入任务描述)
+ * 5. 依赖关系分析 (自动分析任务间依赖)
+ * 6. 并行执行 (独立任务互不依赖)
+ * 7. 质量级别感知 (根据配置调整测试覆盖率)
  */
 class TaskPlanner {
+    userAnswers;
+    taskCounter = 0;
+    constructor(userAnswers) {
+        this.userAnswers = userAnswers || {};
+    }
     /**
-     * Break down a parsed task into sub-tasks
+     * 设置用户回答
      */
-    breakdown(parsedTask, answers) {
-        const userContext = this.extractUserContext(answers);
-        // 有 goals → 按 goals 拆分多任务
-        if (parsedTask.goals.length > 0) {
-            return this.breakdownByGoals(parsedTask, userContext, answers);
-        }
-        // 无 goals → 退化为 planner → coder → tester 三任务
-        return this.breakdownFallback(parsedTask, userContext, answers);
+    setUserAnswers(answers) {
+        this.userAnswers = answers;
     }
     /**
-     * 按 goals 拆分: 每个 goal 一个 coder + 一个 tester
+     * Break down a parsed task into sub-tasks
      */
-    breakdownByGoals(parsedTask, userContext, answers) {
+    breakdown(parsedTask, answers, qualityConfig, plan) {
         const breakdowns = [];
         const seenTitles = new Set();
-        // 0. 设计阶段 (多 goal 时)
-        if (parsedTask.goals.length > 1) {
+        const userContext = this.extractUserContext(answers);
+        // 确定测试覆盖率
+        const coverageTarget = this.getCoverageTarget(qualityConfig, userContext);
+        // 构建全局上下文块（注入到每个子任务描述中，供 agent 参考）
+        const globalContext = this.buildGlobalContext(parsedTask, userContext, plan);
+        // 0. 设计阶段任务 (根据复杂度判断)
+        let designTaskId;
+        if (this.needsDesignPhase(parsedTask)) {
+            designTaskId = this.generateTaskId();
             breakdowns.push({
-                taskId: this.generateTaskId(),
+                taskId: designTaskId,
                 title: '架构设计和任务规划',
                 description: `分析需求，设计整体架构，规划实现方案
 
-## 用户需求
-${userContext.objective || parsedTask.title}
-
-## 技术栈
-${userContext.techStack?.join(', ') || '未指定'}
+${globalContext}
 
 ## 输出
 - 架构设计文档
@@ -57,57 +64,62 @@ ${userContext.techStack?.join(', ') || '未指定'}
                 ]
             });
         }
-        // 1. 为每个 goal 创建 coder + tester 任务对
+        // 1. 为每个目标创建开发+测试任务（并行，只依赖设计任务）
         const devTaskIds = [];
         for (let i = 0; i < parsedTask.goals.length; i++) {
             const goal = parsedTask.goals[i];
-            if (seenTitles.has(goal))
+            // 跳过重复项
+            if (seenTitles.has(goal)) {
                 continue;
+            }
             seenTitles.add(goal);
+            // 创建开发任务 — 所有开发任务并行，仅依赖设计任务
             const devTaskId = this.generateTaskId();
             devTaskIds.push(devTaskId);
-            // 开发任务
+            const acceptanceCriteria = this.generateAcceptanceCriteria(goal, userContext);
             breakdowns.push({
                 taskId: devTaskId,
                 title: `实现: ${goal}`,
-                description: this.buildTaskDescription(goal, userContext, answers),
+                description: this.buildTaskDescription(goal, globalContext),
                 priority: this.determinePriority(i),
-                dependencies: i === 0 && parsedTask.goals.length > 1
-                    ? [breakdowns[0].taskId]
-                    : (i > 0 ? [devTaskIds[i - 1]] : []),
+                // 并行: 所有开发任务只依赖设计任务（如果有），互不依赖
+                dependencies: designTaskId ? [designTaskId] : [],
                 estimatedComplexity: this.estimateComplexity(goal),
                 assignedAgent: 'coder',
                 phase: 'develop',
-                acceptanceCriteria: this.generateAcceptanceCriteria(goal, userContext)
+                acceptanceCriteria,
+                testTaskId: undefined // 稍后关联
             });
-            // 配对的测试任务
+            // 为每个开发任务创建配对的测试任务
             const testTaskId = this.generateTaskId();
             breakdowns.push({
                 taskId: testTaskId,
                 title: `测试: ${goal}`,
-                description: this.buildTestDescription(goal, devTaskId, userContext),
+                description: this.buildTestDescription(goal, devTaskId, coverageTarget, globalContext),
                 priority: this.determinePriority(i),
-                dependencies: [devTaskId],
+                dependencies: [devTaskId], // 测试依赖对应的开发任务
                 estimatedComplexity: 'medium',
                 assignedAgent: 'tester',
                 phase: 'verify',
                 acceptanceCriteria: [
-                    `单元测试覆盖率 >= ${userContext.testCoverage || '60%'}`,
+                    `单元测试覆盖率 >= ${coverageTarget}%`,
                     '边界情况已测试',
                     '异常处理已验证',
                     '所有测试通过'
                 ]
             });
-            // 关联测试任务
+            // 关联测试任务 ID
             breakdowns[breakdowns.length - 2].testTaskId = testTaskId;
         }
-        // 2. 代码审查 (有开发任务时)
-        if (devTaskIds.length > 1) {
+        // 2. 代码审查任务 (仅在有开发任务时创建)
+        if (devTaskIds.length > 0) {
             breakdowns.push({
                 taskId: this.generateTaskId(),
                 title: '代码审查',
                 description: `对所有开发任务进行代码审查
 
+${globalContext}
+
 ## 审查范围
 ${devTaskIds.map(id => `- ${id}`).join('\n')}
 
@@ -117,7 +129,7 @@ ${devTaskIds.map(id => `- ${id}`).join('\n')}
 - 性能
 - 最佳实践`,
                 priority: 'P1',
-                dependencies: devTaskIds,
+                dependencies: devTaskIds, // 审查依赖所有开发任务完成
                 estimatedComplexity: 'medium',
                 assignedAgent: 'reviewer',
                 phase: 'verify',
@@ -129,134 +141,135 @@ ${devTaskIds.map(id => `- ${id}`).join('\n')}
                 ]
             });
         }
-        return breakdowns;
-    }
-    /**
-     * 无 goals 时的退化模式: planner → coder → tester
-     * 把 rawContent 整体交给 planner 分析，生成 PLAN.md
-     * coder 基于 PLAN.md 实现
-     */
-    breakdownFallback(parsedTask, userContext, answers) {
-        const planTaskId = this.generateTaskId();
-        const devTaskId = this.generateTaskId();
-        const testTaskId = this.generateTaskId();
-        // 组装完整上下文
-        const contextParts = [];
-        contextParts.push(`## 原始需求\n${parsedTask.rawContent || parsedTask.description || parsedTask.title}`);
-        if (userContext.objective)
-            contextParts.push(`## 核心目标\n${userContext.objective}`);
-        if (userContext.techStack?.length)
-            contextParts.push(`## 技术栈\n${userContext.techStack.join(', ')}`);
-        if (parsedTask.constraints.length)
-            contextParts.push(`## 约束\n${parsedTask.constraints.map(c => `- ${c}`).join('\n')}`);
-        const brainstormKeys = ['brainstormAnswers', 'insights', 'designNotes'];
-        for (const key of brainstormKeys) {
-            if (answers[key])
-                contextParts.push(`## ${key}\n${answers[key]}`);
-        }
-        const fullContext = contextParts.join('\n\n');
-        return [
-            {
-                taskId: planTaskId,
-                title: `${parsedTask.title} - 需求分析与规划`,
-                description: `分析需求并制定实现计划。
-
-${fullContext}
-
-## 你的任务
-1. 深入理解需求
-2. 设计实现方案
-3. 将需求拆解为具体步骤
-
-## 输出: PLAN.md
-在 .openmatrix/plan/ 目录创建 PLAN.md，格式:
-
-# 实现计划
-
-## 架构设计
-(整体方案)
-
-## 实现步骤
-### 步骤 1: (标题)
-- 描述: (具体做什么)
-- 文件: (涉及哪些文件)
-- 验收: (怎么判断完成)
+        // 3. 集成测试任务 (如果有多个交付物)
+        if (parsedTask.deliverables.length > 1) {
+            breakdowns.push({
+                taskId: this.generateTaskId(),
+                title: '集成测试',
+                description: `验证所有交付物正确集成
 
-### 步骤 2: (标题)
-...
+${globalContext}
 
-## 注意事项
-- (风险、约束等)`,
-                priority: 'P0',
-                dependencies: [],
-                estimatedComplexity: 'high',
-                assignedAgent: 'planner',
-                phase: 'design',
+## 测试范围
+- 模块间接口
+- 端到端流程
+- 数据流验证`,
+                priority: 'P1',
+                dependencies: devTaskIds,
+                estimatedComplexity: 'medium',
+                assignedAgent: 'tester',
+                phase: 'verify',
                 acceptanceCriteria: [
-                    'PLAN.md 已创建在 .openmatrix/plan/',
-                    '实现步骤清晰可执行',
-                    '每步有明确的文件和验收标准'
+                    '所有模块正确集成',
+                    '端到端流程通过',
+                    '接口兼容性验证',
+                    '集成测试报告完整'
                 ]
-            },
-            {
-                taskId: devTaskId,
-                title: `${parsedTask.title} - 开发实现`,
-                description: `根据 PLAN.md 实现功能。
-
-${fullContext}
-
-## 执行方式
-1. 先读取 .openmatrix/plan/PLAN.md
-2. 按照步骤逐一实现
-3. 每完成一个步骤，验证对应的验收标准
-
-## 输出
-- 完整的功能代码
-- 必要的配置文件`,
-                priority: 'P1',
-                dependencies: [planTaskId],
+            });
+        }
+        // 4. E2E 测试任务 (如果启用)
+        if (userContext.e2eTests) {
+            const e2eTaskId = this.generateTaskId();
+            const e2eType = userContext.e2eType || 'web';
+            const allTestDependencies = [...devTaskIds];
+            breakdowns.forEach(b => {
+                if (b.phase === 'verify' && b.title.startsWith('测试:')) {
+                    allTestDependencies.push(b.taskId);
+                }
+            });
+            breakdowns.push({
+                taskId: e2eTaskId,
+                title: '端到端(E2E)测试',
+                description: this.buildE2ETestDescription(e2eType, parsedTask, userContext),
+                priority: 'P0',
+                dependencies: allTestDependencies,
                 estimatedComplexity: 'high',
-                assignedAgent: 'coder',
-                phase: 'develop',
+                assignedAgent: 'tester',
+                phase: 'verify',
                 acceptanceCriteria: [
-                    'PLAN.md 中所有步骤已实现',
-                    '代码可编译运行',
-                    '无严重 bug'
+                    '所有 E2E 测试用例通过',
+                    '关键用户流程验证完成',
+                    '跨浏览器/设备兼容性验证',
+                    'E2E 测试报告已生成',
+                    '无阻塞级别的缺陷'
                 ]
-            },
-            {
-                taskId: testTaskId,
-                title: `${parsedTask.title} - 验证`,
-                description: `验证实现是否满足需求。
+            });
+        }
+        // 5. 文档任务 (如果需要)
+        if (userContext.documentationLevel && userContext.documentationLevel !== '无需文档') {
+            breakdowns.push({
+                taskId: this.generateTaskId(),
+                title: '文档编写',
+                description: `编写项目文档
 
-## 原始需求
-${parsedTask.rawContent || parsedTask.title}
+## 文档级别
+${userContext.documentationLevel}
 
-## 验证方式
-1. 读取 PLAN.md 中的验收标准
-2. 逐一验证每个步骤
-3. 运行测试（如有）
-4. 检查代码质量`,
-                priority: 'P1',
-                dependencies: [devTaskId],
-                estimatedComplexity: 'medium',
-                assignedAgent: 'tester',
-                phase: 'verify',
+## 文档内容
+- README 更新
+- API 文档
+- 使用说明`,
+                priority: 'P2',
+                dependencies: devTaskIds,
+                estimatedComplexity: 'low',
+                assignedAgent: 'executor',
+                phase: 'accept',
                 acceptanceCriteria: [
-                    '所有功能正常运行',
-                    'PLAN.md 中验收标准全部通过',
-                    '无严重代码问题'
+                    'README 已更新',
+                    'API 文档完整',
+                    '使用说明清晰'
                 ]
-            }
+            });
+        }
+        return breakdowns;
+    }
+    /**
+     * 判断是否需要设计阶段
+     *
+     * 条件: 多个 goal，或 goal 包含复杂关键词
+     */
+    needsDesignPhase(parsedTask) {
+        if (parsedTask.goals.length > 1)
+            return true;
+        // 单 goal 但包含复杂关键词
+        const complexKeywords = [
+            '系统', '架构', '模块', '集成', '完整', '平台',
+            '体系', '框架', '全栈', '端到端', '多个', '一系列',
+            'system', 'architecture', 'framework', 'fullstack', 'integration'
         ];
+        const allText = `${parsedTask.title} ${parsedTask.goals.join(' ')} ${parsedTask.description}`.toLowerCase();
+        return complexKeywords.some(kw => allText.includes(kw.toLowerCase()));
     }
-    // --- 工具方法 ---
+    /**
+     * 获取测试覆盖率目标
+     */
+    getCoverageTarget(qualityConfig, userContext) {
+        // 优先使用 qualityConfig
+        if (qualityConfig) {
+            return qualityConfig.minCoverage;
+        }
+        // 其次使用用户回答
+        if (userContext?.testCoverage) {
+            const match = userContext.testCoverage.match(/(\d+)/);
+            if (match)
+                return parseInt(match[1], 10);
+        }
+        // 默认
+        return 60;
+    }
+    /**
+     * 提取用户上下文
+     */
     extractUserContext(answers) {
+        const e2eAnswer = answers['E2E测试'] || answers['e2eTests'] || answers['e2e'];
+        const e2eTypeAnswer = answers['E2E类型'] || answers['e2eType'];
         return {
             objective: answers['目标'] || answers['objective'],
             techStack: this.parseArrayAnswer(answers['技术栈'] || answers['techStack']),
             testCoverage: answers['测试'] || answers['testCoverage'],
             documentationLevel: answers['文档'] || answers['documentationLevel'],
+            e2eTests: e2eAnswer === 'true' || e2eAnswer === '✅ 启用 E2E 测试' || e2eAnswer === '是',
+            e2eType: e2eTypeAnswer || 'web',
             additionalContext: answers
         };
     }
@@ -265,35 +278,58 @@ ${parsedTask.rawContent || parsedTask.title}
             return [];
         return answer.split(/[,，\n]/).map(s => s.trim()).filter(Boolean);
     }
-    buildTaskDescription(goal, userContext, answers) {
+    /**
+     * 构建全局上下文块（注入到每个子任务描述中）
+     */
+    buildGlobalContext(parsedTask, userContext, plan) {
         const parts = [];
-        parts.push(`## 任务目标\n${goal}\n`);
-        if (userContext.objective)
-            parts.push(`## 整体目标\n${userContext.objective}\n`);
-        if (userContext.techStack?.length) {
-            parts.push(`## 技术栈要求\n${userContext.techStack.map(t => `- ${t}`).join('\n')}\n`);
+        if (parsedTask.title) {
+            parts.push(`## 整体任务\n${parsedTask.title}`);
+        }
+        if (parsedTask.description) {
+            parts.push(`## 任务描述\n${parsedTask.description}`);
+        }
+        if (plan) {
+            parts.push(`## 执行计划\n${plan}`);
+        }
+        if (parsedTask.goals.length > 0) {
+            parts.push(`## 所有目标\n${parsedTask.goals.map((g, i) => `${i + 1}. ${g}`).join('\n')}`);
         }
-        const relevantAnswers = Object.entries(answers).filter(([key]) => !['目标', '技术栈', '测试', '文档', 'objective', 'techStack', 'testCoverage', 'documentationLevel'].includes(key));
-        if (relevantAnswers.length > 0) {
-            parts.push(`## 其他要求\n${relevantAnswers.map(([k, v]) => `- ${k}: ${v}`).join('\n')}\n`);
+        if (parsedTask.constraints.length > 0) {
+            parts.push(`## 约束条件\n${parsedTask.constraints.map(c => `- ${c}`).join('\n')}`);
         }
-        parts.push(`## 输出要求
+        if (parsedTask.deliverables.length > 0) {
+            parts.push(`## 交付物\n${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}`);
+        }
+        if (userContext.techStack && userContext.techStack.length > 0) {
+            parts.push(`## 技术栈\n${userContext.techStack.map(t => `- ${t}`).join('\n')}`);
+        }
+        if (userContext.additionalContext) {
+            const relevantAnswers = Object.entries(userContext.additionalContext).filter(([key]) => !['目标', '技术栈', '测试', '文档', 'objective', 'techStack', 'testCoverage', 'documentationLevel'].includes(key));
+            if (relevantAnswers.length > 0) {
+                parts.push(`## 其他要求\n${relevantAnswers.map(([k, v]) => `- ${k}: ${v}`).join('\n')}`);
+            }
+        }
+        return parts.join('\n');
+    }
+    buildTaskDescription(goal, globalContext) {
+        return `## 当前子任务目标\n${goal}\n\n${globalContext}\n\n## 输出要求
 - 完成功能实现
 - 代码可编译
 - 遵循项目规范
-- 添加必要注释`);
-        return parts.join('\n');
+- 添加必要注释`;
     }
-    buildTestDescription(goal, devTaskId, userContext) {
-        const coverage = this.parseCoverage(userContext.testCoverage || '60%');
+    buildTestDescription(goal, devTaskId, coverageTarget, globalContext) {
         return `## 测试目标
 为 "${goal}" 编写测试用例
 
+${globalContext}
+
 ## 关联开发任务
 ${devTaskId}
 
 ## 测试要求
-- 单元测试覆盖率 >= ${coverage}%
+- 单元测试覆盖率 >= ${coverageTarget}%
 - 测试正常流程
 - 测试边界情况
 - 测试异常处理
@@ -307,9 +343,90 @@ ${devTaskId}
 - 测试报告
 - 覆盖率报告`;
     }
-    parseCoverage(coverageStr) {
-        const match = coverageStr.match(/(\d+)/);
-        return match ? parseInt(match[1], 10) : 60;
+    buildE2ETestDescription(e2eType, parsedTask, userContext) {
+        const typeConfig = this.getE2ETypeConfig(e2eType);
+        return `## E2E 测试目标
+执行完整的端到端测试，验证关键用户流程
+
+## 应用类型
+${typeConfig.description}
+
+## 测试框架
+${typeConfig.frameworks.map(f => `- ${f}`).join('\n')}
+
+## 测试范围
+${parsedTask.goals.map((g, i) => `${i + 1}. ${g}`).join('\n')}
+
+## 关键用户流程
+根据应用功能，测试以下流程:
+${this.generateUserFlows(parsedTask, e2eType)}
+
+## 测试环境
+${typeConfig.environments.map(e => `- ${e}`).join('\n')}
+
+## 测试要求
+1. **关键路径覆盖**: 所有核心用户流程必须有 E2E 测试
+2. **断言完整**: 每个测试步骤必须有明确的断言
+3. **等待策略**: 使用合理的等待机制，避免硬编码延迟
+4. **数据隔离**: 测试数据独立，不影响其他测试
+5. **清理机制**: 测试后清理创建的数据
+
+## 输出要求
+- E2E 测试文件 (tests/e2e/*.spec.ts)
+- 测试执行报告
+- 截图/录像 (失败时)
+- 测试覆盖率报告 (如有)
+
+## 运行命令
+\`\`\`bash
+${typeConfig.runCommand}
+\`\`\`
+
+## 验收标准
+- [ ] 所有 E2E 测试用例通过
+- [ ] 关键用户流程验证完成
+- [ ] 跨浏览器/设备兼容性验证
+- [ ] E2E 测试报告已生成
+- [ ] 无阻塞级别的缺陷`;
+    }
+    getE2ETypeConfig(type) {
+        const configs = {
+            web: {
+                description: 'Web 应用 (浏览器)',
+                frameworks: ['Playwright (推荐)', 'Cypress', 'Selenium WebDriver', 'Puppeteer'],
+                environments: ['Chrome', 'Firefox', 'Safari', 'Edge', 'Mobile Viewports'],
+                runCommand: 'npx playwright test --reporter=html'
+            },
+            mobile: {
+                description: '移动应用 (iOS/Android)',
+                frameworks: ['Appium', 'Detox (React Native)', 'XCUITest (iOS)', 'Espresso (Android)'],
+                environments: ['iOS Simulator', 'Android Emulator', 'Real Devices'],
+                runCommand: 'npx appium --base-path /wd/hub && npm run test:e2e'
+            },
+            gui: {
+                description: 'GUI 桌面应用 (Electron/Native)',
+                frameworks: ['Playwright for Electron', 'Spectron (Electron)', 'Robot Framework', 'PyAutoGUI'],
+                environments: ['Windows', 'macOS', 'Linux'],
+                runCommand: 'npm run test:e2e'
+            }
+        };
+        return configs[type];
+    }
+    generateUserFlows(parsedTask, type) {
+        const flows = [];
+        const goals = parsedTask.goals;
+        goals.forEach((goal, i) => {
+            flows.push(`\n### 流程 ${i + 1}: ${goal}`);
+            flows.push('```gherkin');
+            flows.push(`Feature: ${goal}`);
+            flows.push('');
+            flows.push('  Scenario: 正常流程');
+            flows.push(`    Given 用户已启动应用`);
+            flows.push(`    When 用户执行 "${goal}" 操作`);
+            flows.push(`    Then 操作成功完成`);
+            flows.push('```');
+        });
+        return flows.join('\n');
     }
     generateAcceptanceCriteria(goal, userContext) {
         const criteria = [
@@ -318,17 +435,19 @@ ${devTaskId}
             '代码符合项目规范',
             '必要的注释已添加'
         ];
-        if (userContext.testCoverage)
+        if (userContext.testCoverage) {
             criteria.push(`测试覆盖率 >= ${userContext.testCoverage}`);
-        if (userContext.techStack?.length)
+        }
+        if (userContext.techStack?.length) {
             criteria.push(`使用指定技术栈: ${userContext.techStack.join(', ')}`);
-        criteria.push('无安全隐患', '边界情况已处理');
+        }
+        criteria.push('无安全隐患');
+        criteria.push('边界情况已处理');
         return criteria;
     }
     generateTaskId() {
-        const timestamp = Date.now().toString(36).toUpperCase();
-        const rand = Math.random().toString(36).slice(2, 4).toUpperCase();
-        return `TASK-${timestamp}${rand}`;
+        this.taskCounter++;
+        return `TASK-${String(this.taskCounter).padStart(3, '0')}`;
     }
     determinePriority(goalIndex) {
         if (goalIndex === 0)

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

@@ -13,7 +13,6 @@ export declare class StateManager {
         timeout: number;
         dependencies: string[];
         assignedAgent: string;
-        id?: string;
     }): Promise<Task>;
     getTask(taskId: string): Promise<Task | null>;
     updateTask(taskId: string, updates: Partial<Task>): Promise<void>;

package/dist/storage/state-manager.js

@@ -53,7 +53,7 @@ class StateManager {
         this.stateCache = newState;
     }
     async createTask(input) {
-        const taskId = input.id || this.generateTaskId();
+        const taskId = this.generateTaskId();
         const now = new Date().toISOString();
         const task = {
             id: taskId,
@@ -74,7 +74,7 @@ class StateManager {
             createdAt: now,
             updatedAt: now
         };
-        await this.store.writeJson(`tasks/${taskId}/task.json`, task);
+        await this.store.writeJson(`tasks/${taskId}.json`, task);
         // Update statistics
         const state = await this.getState();
         await this.updateState({
@@ -87,7 +87,7 @@ class StateManager {
         return task;
     }
     async getTask(taskId) {
-        return await this.store.readJson(`tasks/${taskId}/task.json`);
+        return await this.store.readJson(`tasks/${taskId}.json`);
     }
     async updateTask(taskId, updates) {
         const task = await this.getTask(taskId);
@@ -99,17 +99,17 @@ class StateManager {
             ...updates,
             updatedAt: new Date().toISOString()
         };
-        await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
+        await this.store.writeJson(`tasks/${taskId}.json`, updatedTask);
         // Update statistics if status changed
         if (updates.status && updates.status !== oldStatus) {
             await this.updateTaskStatistics(oldStatus, updates.status);
         }
     }
     async listTasks() {
-        const dirs = await this.store.listDirs('tasks');
+        const files = await this.store.listFiles('tasks');
         const tasks = [];
-        for (const dir of dirs) {
-            const task = await this.getTask(dir);
+        for (const file of files) {
+            const task = await this.store.readJson(`tasks/${file}`);
             if (task)
                 tasks.push(task);
         }
@@ -144,9 +144,9 @@ class StateManager {
         return `run-${date}-${rand}`;
     }
     generateTaskId() {
-        const timestamp = Date.now().toString(36).toUpperCase();
-        const rand = Math.random().toString(36).slice(2, 4).toUpperCase();
-        return `TASK-${timestamp}${rand}`;
+        const count = this.stateCache?.statistics.totalTasks ?? 0;
+        const seq = count + 1;
+        return `TASK-${String(seq).padStart(3, '0')}`;
     }
     // ============ Approval Methods ============
     async saveApproval(approval) {