speccore 6.69.0 → 6.71.3

package/dist/commands/iteration/split.js

@@ -47,6 +47,75 @@ const prompt_builder_1 = require("../../core/prompt-builder");
 const index_guard_1 = require("../../core/index-guard");
 const spec_paths_1 = require("../../core/spec-paths");
 const questions_1 = require("../../core/questions");
+const pipeline_engine_1 = require("../../core/pipeline-engine");
+/**
+ * 将 AI 返回的 scope 简写映射到 CONSTITUTION.md 标准端名
+ * v6.69.3+: 解决中文简写（如 "后端"、"admin"）导致目录名错误的问题
+ */
+function normalizeScopePlatforms(scopeArr, standardPlatforms) {
+    const result = [];
+    const used = new Set();
+    for (const raw of scopeArr) {
+        const s = raw.trim();
+        if (!s)
+            continue;
+        // 1. 如果已经是标准端名，直接使用
+        if (standardPlatforms.includes(s)) {
+            if (!used.has(s)) {
+                result.push(s);
+                used.add(s);
+            }
+            continue;
+        }
+        // 2. 后端类简写 → 匹配第一个后端端名
+        if (/后端|backend|服务端|server/i.test(s)) {
+            const backendPlatform = standardPlatforms.find(p => /-(service|api|server|backend)$/i.test(p) || p.startsWith('后台'));
+            if (backendPlatform && !used.has(backendPlatform)) {
+                result.push(backendPlatform);
+                used.add(backendPlatform);
+            }
+            continue;
+        }
+        // 3. 前端类简写 → 模糊匹配标准端名
+        const lower = s.toLowerCase();
+        const matched = standardPlatforms.find(p => {
+            const pl = p.toLowerCase();
+            // 直接包含关系：admin-web 包含 admin
+            return pl.includes(lower) || lower.includes(pl);
+        });
+        if (matched && !used.has(matched)) {
+            result.push(matched);
+            used.add(matched);
+            continue;
+        }
+        // 4. 关键词匹配
+        const keywordMap = {
+            'h5': ['h5-mobile', 'h5', 'mobile', '移动端'],
+            'mobile': ['h5-mobile', 'h5', 'mobile', '移动端'],
+            '小程序': ['miniapp', 'mini-app', '小程序'],
+            'admin': ['admin-web', 'admin', '后台管理'],
+            'web': ['admin-web', 'web', 'h5-mobile'],
+            'app': ['app', 'android', 'ios'],
+            '安卓': ['android'],
+            'ios': ['ios'],
+        };
+        const candidates = keywordMap[lower];
+        if (candidates) {
+            const found = standardPlatforms.find(p => candidates.some(c => p.toLowerCase().includes(c.toLowerCase())));
+            if (found && !used.has(found)) {
+                result.push(found);
+                used.add(found);
+                continue;
+            }
+        }
+        // 5. 无法匹配时保留原始值（后续可能创建非法目录，但至少不丢失信息）
+        if (!used.has(s)) {
+            result.push(s);
+            used.add(s);
+        }
+    }
+    return result.length > 0 ? result : standardPlatforms;
+}
 /** 将名称转为目录安全的短 slug（2-4 词） */
 function slugify(name) {
     const cleaned = name
@@ -139,6 +208,62 @@ async function detectPlatforms(iterationDir, specified) {
     return ['web']; // 默认
 }
 async function iterationSplitCommand(options) {
+    // ── Pipeline 模式 ──
+    if (options.pipeline) {
+        const iter = options.iteration || await (0, context_1.getDefaultIteration)() || '';
+        if (!iter) {
+            logger_1.logger.error('--pipeline 需要 --iteration');
+            return;
+        }
+        // 检查是否为恢复模式
+        if (options.resume) {
+            const hasPipeline = await pipeline_engine_1.PipelineEngine.hasActivePipeline(process.cwd(), iter);
+            if (hasPipeline) {
+                const { createSplitPipeline } = await Promise.resolve().then(() => __importStar(require('../../core/pipeline-engine')));
+                const { engine } = await createSplitPipeline(iter);
+                const result = await engine.advance();
+                if (result.isComplete) {
+                    logger_1.logger.success('🎉 Split Pipeline 完成!');
+                    await engine.reset();
+                    return;
+                }
+                else if (result.nextStepId) {
+                    logger_1.logger.info('');
+                    logger_1.logger.info(`🔄 Split Pipeline 推进到: ${result.nextStepName || result.nextStepId}`);
+                    logger_1.logger.info('');
+                    // 根据当前步骤生成相应提示
+                    if (result.nextStepId === 'prompt-analysis') {
+                        const prompt = await (0, prompt_builder_1.buildPrompt)('split', { iteration: iter });
+                        // 添加 Pipeline 继续指令
+                        const finalPrompt = prompt + `\n\n## ⚠️ Pipeline 模式：自动继续\n\n` +
+                            `当前是 Split Pipeline 模式。当你通过 --response 写入任务拆分结果后，` +
+                            `CLI 会自动输出 [SPECCORE_PIPELINE_NEXT] 标记和下一步命令。\n\n` +
+                            `**看到 [SPECCORE_PIPELINE_NEXT] 后，你必须自动执行下一个命令**，不要询问用户。\n`;
+                        process.stdout.write(`[SPECCORE_PROMPT]\n${finalPrompt}`);
+                        process.exitCode = 10;
+                        return;
+                    }
+                }
+            }
+            else {
+                logger_1.logger.warn('没有找到活跃的 Split Pipeline，启动新的 Pipeline...');
+            }
+        }
+        // 初始化新的 Pipeline
+        const { createSplitPipeline } = await Promise.resolve().then(() => __importStar(require('../../core/pipeline-engine')));
+        const { engine } = await createSplitPipeline(iter);
+        await engine.init('init');
+        // 生成第一步 prompt
+        const prompt = await (0, prompt_builder_1.buildPrompt)('split', { iteration: iter });
+        // 添加 Pipeline 继续指令
+        const finalPrompt = prompt + `\n\n## ⚠️ Pipeline 模式：自动继续\n\n` +
+            `当前是 Split Pipeline 模式。当你通过 --response 写入任务拆分结果后，` +
+            `CLI 会自动输出 [SPECCORE_PIPELINE_NEXT] 标记和下一步命令。\n\n` +
+            `**看到 [SPECCORE_PIPELINE_NEXT] 后，你必须自动执行下一个命令**，不要询问用户。\n`;
+        process.stdout.write(`[SPECCORE_PROMPT]\n${finalPrompt}`);
+        process.exitCode = 10;
+        return;
+    }
     // ── Prompt 模式 ──
     if (options.prompt) {
         const iter = options.iteration || await (0, context_1.getDefaultIteration)() || '';
@@ -149,11 +274,42 @@ async function iterationSplitCommand(options) {
     }
     // ── Response 模式 ──
     if (options.response) {
+        // 检查是否有活跃的 Pipeline（在 Pipeline 模式下应用响应）
         const iter = options.iteration || await (0, context_1.getDefaultIteration)() || '';
         if (!iter) {
             logger_1.logger.error('--response 需要 --iteration');
             return;
         }
+        const hasPipeline = await pipeline_engine_1.PipelineEngine.hasActivePipeline(process.cwd(), iter);
+        if (hasPipeline) {
+            const { createSplitPipeline } = await Promise.resolve().then(() => __importStar(require('../../core/pipeline-engine')));
+            const { engine } = await createSplitPipeline(iter);
+            await engine.advance();
+            const state = await engine.getState();
+            if (state?.currentStep === 'done') {
+                logger_1.logger.success('🎉 Split Pipeline 完成!');
+                await engine.reset();
+            }
+            else if (state?.currentStep) {
+                logger_1.logger.info('');
+                logger_1.logger.info(`🔄 Split Pipeline 推进: ${state.currentStep}`);
+                logger_1.logger.info('');
+                // 生成下一步 prompt
+                let nextPrompt;
+                if (state.currentStep === 'creation') {
+                    // 在创建阶段，我们已完成拆分，可以生成创建任务的提示
+                    nextPrompt = `任务拆分已完成，正在创建任务目录结构...\n\n请继续执行后续操作。`;
+                }
+                else {
+                    const promptResult = await (0, prompt_builder_1.buildPrompt)('split', { iteration: iter });
+                    nextPrompt = typeof promptResult === 'string' ? promptResult : JSON.stringify(promptResult);
+                }
+                process.stdout.write(`[SPECCORE_PIPELINE_NEXT]\n${nextPrompt}`);
+                process.exitCode = 10;
+            }
+            return;
+        }
+        // 非 Pipeline 模式的 Response 处理
         const iterDir = (0, path_1.join)('Iteration-' + iter, '030-tasks');
         await (0, fs_extra_1.ensureDir)(iterDir);
         const backups = [];
@@ -193,18 +349,13 @@ async function iterationSplitCommand(options) {
                         content += `\n\n接口:\n${apis}`;
                     if (acs)
                         content += `\n\n验收标准:\n${acs}`;
-                    // 从 scope 提取平台列表（后端 + 前端各端）
-                    const taskScopePlatforms = [];
-                    const isBackend = scopeArr.some((s) => /后端|backend/i.test(s));
-                    const fePlatforms = scopeArr.filter((s) => !/后端|backend/i.test(s)).map((s) => s.trim()).filter(Boolean);
-                    if (isBackend)
-                        taskScopePlatforms.push('backend');
-                    taskScopePlatforms.push(...fePlatforms);
+                    // v6.69.3+: 将 AI 返回的 scope 简写映射到标准端名
+                    const taskScopePlatforms = normalizeScopePlatforms(scopeArr, allPlatforms);
                     const section = {
                         name: task.name || `Task ${i + 1}`,
                         content,
                         level: 2,
-                        platform: isBackend ? 'backend' : (fePlatforms[0] || undefined),
+                        platform: taskScopePlatforms[0] || undefined,
                     };
                     section._complexity = {
                         estimatedHours: task.estimatedHours || 8,
@@ -603,8 +754,10 @@ async function iterationSplitCommand(options) {
             const recommendedGranularity = options.granularity || recommendGranularity(teamSize);
             const granularityLabel = GRANULARITY_RULES[recommendedGranularity].label;
             const granularityHint = GRANULARITY_RULES[recommendedGranularity].desc;
-            // 构建完整 prompt
-            let splitPrompt = buildSplitPrompt(iteration, constitutionContent, reqContent2, specContents, staffing, teamSize, granularityLabel, granularityHint);
+            // 获取标准端名列表（用于 prompt 注入和 scope 规范化）
+            const allPlatforms = await detectPlatforms(iterationDir);
+            // 构建完整 prompt（v6.69.3+: 传入标准端名列表，确保 AI 使用正确的端名）
+            let splitPrompt = buildSplitPrompt(iteration, constitutionContent, reqContent2, specContents, staffing, teamSize, granularityLabel, granularityHint, allPlatforms);
             // 注入全局上下文（INDEX + TOC 目录，AI 自主读取）
             const { loadGlobalContext, formatGlobalContext } = await Promise.resolve().then(() => __importStar(require('../../core/prompt-builder')));
             const globalCtx = await loadGlobalContext(process.cwd(), 'split');
@@ -1050,9 +1203,18 @@ ${taskPlatforms.map((p) => `| ${subtaskIdMap.get(p)} | ${p} | ${owner} | 🔲
     await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'created-at'), today);
     await (0, fs_extra_1.ensureDir)((0, path_1.join)(taskDir, '_shared'));
     await (0, fs_extra_1.ensureDir)((0, path_1.join)(taskDir, '00-specs'));
-    const contractYaml = generateApiContract(section);
-    if (contractYaml) {
-        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml'), contractYaml);
+    // v6.70.0+: 优先复制全局 API_CONTRACT.yaml（全局契约是单一真相源）
+    const globalContractPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'API_CONTRACT.yaml');
+    if (await (0, fs_extra_1.pathExists)(globalContractPath)) {
+        const globalContract = await (0, fs_extra_1.readFile)(globalContractPath, 'utf-8');
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml'), globalContract);
+    }
+    else {
+        // 回退：从 section content 提取 API 生成任务级契约
+        const contractYaml = generateApiContract(section);
+        if (contractYaml) {
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml'), contractYaml);
+        }
     }
     // ── 4. 核心规格写入 00-specs/（REQ/TECH/SCHEMA/CHANGELOG） ──
     const acItems = generateAcceptanceCriteria(section);
@@ -1226,6 +1388,20 @@ ${section.content}
 # 自动拉取: 继承迭代配置
 # 远程名称: 继承迭代配置
 `);
+            // v6.70.0+: 从 section 提取接口/页面清单用于 TASK.md
+            const apiLines = section.content.split('\n').filter(l => l.includes('| GET') || l.includes('| POST') || l.includes('| PUT') || l.includes('| DELETE') || l.includes('| PATCH'));
+            const apiList = apiLines.length > 0
+                ? apiLines.map(l => `- ${l.trim()}`).join('\n')
+                : '- 待补充（从 00-specs/REQ.md 和 TECH.md 提取）';
+            // 前端页面清单（如果是前端端）
+            const pageLines = !isBk ? section.content.split('\n').filter(l => /页面[：:]|路由[：:]|path[：:]|\/\w+/.test(l)) : [];
+            const pageList = pageLines.length > 0
+                ? pageLines.map(l => `- ${l.trim()}`).join('\n')
+                : '- 待补充（从 00-specs/REQ.md 和 TECH.md 提取）';
+            // 依赖信息
+            const dependsOn = (section._dependsOn || []).join(', ') || '无';
+            const sharedCap = section._sharedCapability || '无';
+            const crossDesc = section._description || '—';
             // TASK.md
             await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'TASK.md'), `# ${section.name} — ${platformLabel}
 
@@ -1241,6 +1417,38 @@ ${section.content}
 ## 共享规格引用
 - REQ.md → ../../../00-specs/REQ.md
 - TECH.md → ../../../00-specs/TECH.md
+- API_CONTRACT.yaml → ../../../_shared/API_CONTRACT.yaml
+- CONTEXT.md → ../../../_shared/CONTEXT.md
+
+## 跨端关联
+- **共享能力**: ${sharedCap}
+- **依赖任务**: ${dependsOn}
+- **跨端说明**: ${crossDesc}
+
+## 工作清单
+
+### 第一阶段：需求确认
+- [ ] 阅读 00-specs/REQ.md 确认本任务需求范围
+- [ ] 阅读 _shared/API_CONTRACT.yaml 确认接口契约
+- [ ] 阅读 _shared/CONTEXT.md 确认跨端关联
+
+### 第二阶段：技术方案
+- [ ] 阅读 00-specs/TECH.md 确认技术方案
+- [ ] 确认本端涉及的接口/页面清单
+- [ ] 确认数据模型和字段映射
+
+### 第三阶段：开发实施
+- [ ] 按 TECH.md 实施开发
+- [ ] 编写单元测试/集成测试
+- [ ] 自测通过
+
+### 第四阶段：验收交付
+- [ ] 更新 TASK.md 进度
+- [ ] 提交代码并关联本任务
+- [ ] 通知相关端联调
+
+## ${isBk ? '接口清单' : '页面清单'}
+${isBk ? apiList : pageList}
 
 ## 产出物
 | 产出物 | 状态 | 路径 |
@@ -1280,14 +1488,12 @@ ${section.content}
         };
         // ── 所有端平铺：{端名}/{子任务}/ （v6.49.2+ 统一架构）──
         // 不再区分前后端，所有端平铺在任务目录下
-        // 子任务目录命名规则：{taskId}-{subtaskSlug}（确保多任务同平台不冲突）
+        // 子任务目录名使用 generateSubtaskId 生成的全局唯一 ID：Task-{num}-{platform}
         for (const platform of taskPlatforms) {
             const platformDir = (0, path_1.join)(taskDir, platform);
             const subtaskId = subtaskIdMap.get(platform);
-            const subtaskSlug = slugify(section.name) || 'impl';
-            // 子任务目录名：{taskId}-{subtaskSlug}，确保唯一性
-            const subtaskDirName = `${taskId}-${subtaskSlug}`;
-            const subtaskDir = (0, path_1.join)(platformDir, subtaskDirName);
+            // 子任务目录名 = subtaskId（如 Task-001-booking-service）
+            const subtaskDir = (0, path_1.join)(platformDir, subtaskId);
             const subtaskHours = section._hoursByPlatform?.[platform] || Math.ceil(complexity.estimatedHours / taskPlatforms.length);
             // 判断是否后端（用于生成不同的文档内容）
             const isBk = platform === 'backend' || platform.startsWith('后台') || /-(service|api|server|backend)$/i.test(platform);
@@ -1301,7 +1507,8 @@ ${section.content}
         // 从端列表查找第一个后端端名作为 fallback（v6.48.0+）
         const allPlatforms = await (0, spec_paths_1.parsePlatformList)();
         const fallbackBackend = allPlatforms.find(p => p === 'backend' || p.startsWith('后台') || /-(service|api|server|backend)$/i.test(p)) || 'backend';
-        const autoSubtaskDir = (0, path_1.join)(taskDir, fallbackBackend, `${taskId}-impl`);
+        const fallbackSubtaskId = subtaskIdMap.get(fallbackBackend) || generateSubtaskId(taskNum, fallbackBackend);
+        const autoSubtaskDir = (0, path_1.join)(taskDir, fallbackBackend, fallbackSubtaskId);
         await (0, fs_extra_1.ensureDir)((0, path_1.join)(autoSubtaskDir, '.meta'));
         await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'type'), taskType);
         await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'status'), 'todo');
@@ -1372,7 +1579,8 @@ ${section.content}
         const body = reqContent.replace(/^#[^\n]*\n/, '').trim();
         originalDesc = body.length > 500 ? body.slice(0, 500) + '...' : body;
     }
-    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'CONTEXT.md'), `# 任务上下文
+    // v6.69.3+: CONTEXT.md 写入 _shared/（符合规范），同时保留 00-specs/ 副本供兼容
+    const contextContent = `# 任务上下文
 
 ## 来源追溯
 
@@ -1392,12 +1600,25 @@ ${originalDesc || '> 待补充（执行 analyze 后自动生成）'}
 
 ${relatedTasks.length > 0 ? relatedTasks.join('\n') : '> 暂无关联任务（split 时自动填充）'}
 
+## 跨端关联
+
+> 来自 FUNCTION_MAP.md
+
+| 属性 | 值 |
+|:---|:---|
+| 共享能力 | ${section._sharedCapability || '无'} |
+| 依赖任务 | ${(section._dependsOn || []).join(', ') || '无'} |
+| 跨端说明 | ${section._description || '—'} |
+
 ## 影响范围
 
 | 端 | 影响说明 |
 |:---|:---|
 ${taskPlatforms.map((p) => `| ${p} | 待补充 |`).join('\n')}
-`);
+`;
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '_shared', 'CONTEXT.md'), contextContent);
+    // 兼容：00-specs/ 下也保留一份（部分旧代码可能读取 00-specs/CONTEXT.md）
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'CONTEXT.md'), contextContent);
     // ── 7. 问题追踪 ──
     await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.issues.md'), `# ${section.name} - 问题追踪\n\n> 执行过程中发现的问题记录于此。\n\n`);
 }
@@ -2212,7 +2433,7 @@ ${isH5 ? '移动端优先，适配 375/414/768' :
 /**
  * 构建完整的 AI 智能拆分 Prompt（含 SpecCore 理念 + 粒度规则 + 完整上下文）
  */
-function buildSplitPrompt(iteration, constitutionContent, reqContent, specContents, staffing, teamSize, granularityLabel, granularityHint) {
+function buildSplitPrompt(iteration, constitutionContent, reqContent, specContents, staffing, teamSize, granularityLabel, granularityHint, standardPlatforms) {
     let p = `# SpecCore AI 智能拆分\n\n`;
     p += `> 迭代: ${iteration} | 粒度: ${granularityLabel} | 生成: ${new Date().toISOString().split('T')[0]}\n\n`;
     // 技术宪法
@@ -2250,6 +2471,15 @@ function buildSplitPrompt(iteration, constitutionContent, reqContent, specConten
     }
     p += `\n**超出上限必须再拆，低于下限必须合并。**\n\n`;
     p += `用户可通过 --granularity macro|module|atomic 调整全局粒度。\n\n`;
+    // v6.69.3+: 注入标准端名列表
+    if (standardPlatforms.length > 0) {
+        p += `## 🖥️ 项目端列表（标准端名）\n\n`;
+        p += `本项目已配置以下端，所有 scope、hoursByPlatform 必须使用这些**标准端名**，禁止使用简写或中文：\n\n`;
+        p += `\`${standardPlatforms.join('`, `')}\`\n\n`;
+        p += `- 后端端名示例: \`booking-service\`, \`room-service\`（不是 "后端"、"backend"）\n`;
+        p += `- 前端端名示例: \`admin-web\`, \`h5-mobile\`（不是 "web"、"admin"、"h5"）\n`;
+        p += `- **scope 数组必须使用上述标准端名**，否则会导致目录结构错误\n\n`;
+    }
     // SpecCore 拆分原则
     p += `## ⚙️ SpecCore 拆分原则\n\n`;
     p += `SpecCore 核心理念: "Code by Spec, Not by Vibe" — 每个任务必须有对应的 Spec，AI 在 Spec 约束下工作。\n\n`;
@@ -2328,10 +2558,10 @@ function buildSplitPrompt(iteration, constitutionContent, reqContent, specConten
     p += `    "topic": "english-slug-for-directory",\n`;
     p += `    "type": "feature|bugfix|refactor|research",\n`;
     p += `    "reason": "为什么这样拆分",\n`;
-    p += `    "scope": ["后端", "admin"],\n`;
+    p += `    "scope": ["booking-service", "admin-web"],\n`;
     p += `    "apis": ["POST /api/auth/login"],\n`;
     p += `    "tables": ["users"],\n`;
-    p += `    "hoursByPlatform": { "后端": 8, "admin": 8 },\n`;
+    p += `    "hoursByPlatform": { "booking-service": 8, "admin-web": 8 },\n`;
     p += `    "estimatedHours": 16,\n`;
     p += `    "priority": "high|medium|low",\n`;
     p += `    "dependencies": [],\n`;
@@ -2351,9 +2581,17 @@ function buildSplitPrompt(iteration, constitutionContent, reqContent, specConten
     p += `> 同一模块/领域的任务填相同的值，用于粒度校验和任务分组\n`;
     p += `> **topic** 必须是英文短横线格式（如 \`user-authentication\`、\`product-crud\`），用于生成任务目录名 Task-NNN-{topic}\n`;
     p += `> **sourceFile** 必须填写：该任务对应的 020-specs 源文档路径（如 \`bugs/login-timeout.md\`、\`features/user-auth.md\`、\`refactors/db-pool.md\`），用于在 CONTEXT.md 中生成来源追溯\n`;
-    p += `> **reqContent** 必须填写：该任务的需求描述（含业务规则、数据模型、接口定义），直接写入 REQ.md\n`;
-    p += `> **techContent** 必须填写：该任务的技术方案（含架构设计、核心逻辑、测试策略），直接写入 TECH.md\n`;
-    p += `> reqContent/techContent 是该任务的**子切面**，只包含该任务负责的部分，不是整个功能单元的内容\n\n`;
+    p += `> **reqContent 质量要求（必填，禁止模板化）**：\n`;
+    p += `>   - 必须是**具体的、可执行的需求描述**，不是"待补充"或"参考全局文档"\n`;
+    p += `>   - 包含：业务规则（含边界条件）、数据模型（字段/类型/约束）、接口清单（方法/路径/参数/响应）\n`;
+    p += `>   - 从 020-specs/global/REQUIREMENT.md 和对应端 TECH.md 中提取本任务相关的具体内容\n`;
+    p += `>   - 直接写入 00-specs/REQ.md，执行时 AI 不再重新分析需求\n`;
+    p += `> **techContent 质量要求（必填，禁止模板化）**：\n`;
+    p += `>   - 必须是**具体的技术实现方案**，不是框架模板\n`;
+    p += `>   - 包含：架构设计、核心逻辑伪代码/流程、数据库设计（表结构/索引）、API 详细定义、测试策略\n`;
+    p += `>   - 从 020-specs/global/TECH.md 和对应端 TECH.md 中提取本任务相关的技术细节\n`;
+    p += `>   - 直接写入 00-specs/TECH.md，执行时 AI 据此直接开发\n`;
+    p += `> **质量红线**：如果 reqContent/techContent 只有标题和占位符（如 "<!-- AI-FILL -->"），视为不合格，必须重新生成\n\n`;
     p += `### ⚠️ 工时估算规则（重要）\n\n`;
     p += `- **hoursByPlatform**: 按端分别估算工时，key 对应 scope 中的端名称\n`;
     p += `- **estimatedHours**: 各端工时总和（仅用于展示，不参与粒度校验）\n`;
@@ -2679,6 +2917,89 @@ function parseModulePlatforms(content, allPlatforms) {
     }
     return modules;
 }
+/**
+ * v6.70.0+: 解析 FUNCTION_MAP.md 跨端功能映射表
+ * 返回功能单元列表，含涉及端、共享能力、依赖关系
+ */
+function parseFunctionMap(content, allPlatforms) {
+    const units = [];
+    const lines = content.split('\n');
+    let inTable = false;
+    let platformColIdx = -1;
+    let sharedCapColIdx = -1;
+    let dependsOnColIdx = -1;
+    let descColIdx = -1;
+    for (const line of lines) {
+        // 检测映射表开始（通过表头特征）
+        if (line.includes('功能单元') && line.includes('涉及端')) {
+            inTable = true;
+            // 解析表头，找到各列索引
+            const headerCells = line.split('|').map(c => c.trim()).filter(Boolean);
+            platformColIdx = headerCells.findIndex(c => c.includes('涉及端'));
+            sharedCapColIdx = headerCells.findIndex(c => c.includes('共享能力'));
+            dependsOnColIdx = headerCells.findIndex(c => c.includes('依赖任务'));
+            descColIdx = headerCells.findIndex(c => c.includes('说明'));
+            continue;
+        }
+        if (!inTable)
+            continue;
+        // 检测下一个 ## 标题 → 表格结束
+        if (line.startsWith('## ') && !line.includes('功能映射')) {
+            break;
+        }
+        const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+        if (cells.length < 3)
+            continue;
+        // 分隔行跳过
+        if (cells.every(c => /^[-:]+$/.test(c)))
+            continue;
+        // 表头行（已经处理过，跳过）
+        if (cells.some(c => c.includes('功能单元')) || cells.some(c => c.includes('涉及端'))) {
+            continue;
+        }
+        // 数据行：第2列是功能单元名
+        const unitName = cells[1];
+        if (!unitName || unitName === '#' || unitName === '功能单元')
+            continue;
+        // 解析涉及端
+        let platforms = [];
+        if (platformColIdx >= 0 && platformColIdx < cells.length) {
+            const raw = cells[platformColIdx];
+            if (raw && raw !== '无' && raw !== '—' && raw !== '-') {
+                platforms = raw.split(/[,，]/)
+                    .map(p => p.trim())
+                    .filter(p => p && allPlatforms.includes(p));
+            }
+        }
+        // 涉及端为空 → 回退全端（但保留空列表表示纯文档/无开发）
+        if (platforms.length === 0) {
+            platforms = [...allPlatforms];
+        }
+        // 解析共享能力
+        let sharedCapability = '无';
+        if (sharedCapColIdx >= 0 && sharedCapColIdx < cells.length) {
+            const raw = cells[sharedCapColIdx];
+            if (raw && raw !== '无' && raw !== '—' && raw !== '-') {
+                sharedCapability = raw;
+            }
+        }
+        // 解析依赖任务
+        let dependsOn = [];
+        if (dependsOnColIdx >= 0 && dependsOnColIdx < cells.length) {
+            const raw = cells[dependsOnColIdx];
+            if (raw && raw !== '无' && raw !== '—' && raw !== '-') {
+                dependsOn = raw.split(/[,，]/).map(p => p.trim()).filter(Boolean);
+            }
+        }
+        // 解析说明
+        let description = '';
+        if (descColIdx >= 0 && descColIdx < cells.length) {
+            description = cells[descColIdx];
+        }
+        units.push({ name: unitName, platforms, sharedCapability, dependsOn, description });
+    }
+    return units;
+}
 /**
  * 尝试模块驱动拆分：从功能模块创建任务目录结构
  * 成功返回 true，无功能模块时返回 false（回退到传统流程）
@@ -2688,50 +3009,80 @@ async function tryModuleDrivenSplit(iteration, iterationDir, options) {
     const allPlatforms = await detectPlatforms(iterationDir);
     // 收集功能模块（含涉及端信息）
     const modules = [];
-    // 1. 优先从 global/REQUIREMENT.md 读取功能模块清单（含涉及端）
-    const globalReqPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'REQUIREMENT.md');
-    let modulePlatformsParsed = false;
-    if (await (0, fs_extra_1.pathExists)(globalReqPath)) {
+    // v6.70.0+: 1. 优先从 global/FUNCTION_MAP.md 读取跨端功能映射表
+    const functionMapPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'FUNCTION_MAP.md');
+    let functionMapParsed = false;
+    if (await (0, fs_extra_1.pathExists)(functionMapPath)) {
         try {
-            const content = await (0, fs_extra_1.readFile)(globalReqPath, 'utf-8');
-            const parsed = parseModulePlatforms(content, allPlatforms);
+            const content = await (0, fs_extra_1.readFile)(functionMapPath, 'utf-8');
+            const parsed = parseFunctionMap(content, allPlatforms);
             if (parsed.length > 0) {
-                for (const m of parsed) {
+                for (const u of parsed) {
                     modules.push({
-                        name: m.name,
-                        slug: slugify(m.name),
+                        name: u.name,
+                        slug: slugify(u.name),
                         type: 'feature',
-                        sourceFile: 'global/REQUIREMENT.md',
-                        platforms: m.platforms,
+                        sourceFile: 'global/FUNCTION_MAP.md',
+                        platforms: u.platforms,
+                        sharedCapability: u.sharedCapability,
+                        dependsOn: u.dependsOn,
+                        description: u.description,
                     });
                 }
-                modulePlatformsParsed = true;
-                logger_1.logger.info(`   📋 从 global/REQUIREMENT.md 读取到 ${parsed.length} 个功能模块（含涉及端）`);
+                functionMapParsed = true;
+                logger_1.logger.info(`   📋 从 global/FUNCTION_MAP.md 读取到 ${parsed.length} 个功能单元（严格按映射表拆分）`);
             }
         }
-        catch { }
+        catch (e) {
+            logger_1.logger.debug('解析 FUNCTION_MAP.md 失败:', e);
+        }
     }
-    // 2. 回退：读取 features/*/README.md（无涉及端信息，使用全端）
-    if (!modulePlatformsParsed) {
-        const featuresDir = (0, path_1.join)(reqDir, 'features');
-        if (await (0, fs_extra_1.pathExists)(featuresDir)) {
+    // 2. 回退：从 global/REQUIREMENT.md 读取功能模块清单（含涉及端）
+    if (!functionMapParsed) {
+        const globalReqPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'REQUIREMENT.md');
+        let modulePlatformsParsed = false;
+        if (await (0, fs_extra_1.pathExists)(globalReqPath)) {
             try {
-                const entries = await (0, fs_extra_1.readdir)(featuresDir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.isDirectory() && !entry.name.startsWith('.')) {
-                        const readmePath = (0, path_1.join)(featuresDir, entry.name, 'README.md');
-                        if (await (0, fs_extra_1.pathExists)(readmePath)) {
-                            modules.push({
-                                name: entry.name, slug: slugify(entry.name), type: 'feature',
-                                sourceFile: `features/${entry.name}/README.md`,
-                                platforms: [...allPlatforms],
-                            });
-                        }
+                const content = await (0, fs_extra_1.readFile)(globalReqPath, 'utf-8');
+                const parsed = parseModulePlatforms(content, allPlatforms);
+                if (parsed.length > 0) {
+                    for (const m of parsed) {
+                        modules.push({
+                            name: m.name,
+                            slug: slugify(m.name),
+                            type: 'feature',
+                            sourceFile: 'global/REQUIREMENT.md',
+                            platforms: m.platforms,
+                        });
                     }
+                    modulePlatformsParsed = true;
+                    logger_1.logger.info(`   📋 从 global/REQUIREMENT.md 读取到 ${parsed.length} 个功能模块（含涉及端）`);
                 }
             }
             catch { }
         }
+        // 3. 回退：读取 features/*/README.md（无涉及端信息，使用全端）
+        if (!modulePlatformsParsed) {
+            const featuresDir = (0, path_1.join)(reqDir, 'features');
+            if (await (0, fs_extra_1.pathExists)(featuresDir)) {
+                try {
+                    const entries = await (0, fs_extra_1.readdir)(featuresDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                            const readmePath = (0, path_1.join)(featuresDir, entry.name, 'README.md');
+                            if (await (0, fs_extra_1.pathExists)(readmePath)) {
+                                modules.push({
+                                    name: entry.name, slug: slugify(entry.name), type: 'feature',
+                                    sourceFile: `features/${entry.name}/README.md`,
+                                    platforms: [...allPlatforms],
+                                });
+                            }
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
     }
     // 3. 读取类型文档（bugs/refactors/research）
     for (const typeDir of ['bugs', 'refactors', 'research']) {
@@ -2806,6 +3157,13 @@ async function tryModuleDrivenSplit(iteration, iterationDir, options) {
         section._owner = '未分配';
         section._taskId = taskId;
         section.functionalUnit = mod.name;
+        // v6.70.0+: 传递 FUNCTION_MAP.md 中的扩展信息
+        if (mod.sharedCapability)
+            section._sharedCapability = mod.sharedCapability;
+        if (mod.dependsOn)
+            section._dependsOn = mod.dependsOn;
+        if (mod.description)
+            section._description = mod.description;
         await createTaskFromSection(iterationDir, taskId, section, modPlatforms, mod.type, []);
         createdSections.push(section);
         logger_1.logger.info(`   ✅ 创建: ${taskId} [${mod.type}] — ${mod.name} (${modPlatforms.length} 个端: ${modPlatforms.join(', ')})`);