speccore 8.3.253 → 8.3.254

package/dist/commands/iteration/taskify.js

@@ -0,0 +1,4676 @@
+"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.iterationTaskifyCommand = iterationTaskifyCommand;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const logger_1 = require("../../utils/logger");
+const context_1 = require("../../core/context");
+const feature_source_1 = require("../../core/feature-source");
+const risk_scorer_1 = require("../../core/risk-scorer");
+const global_counters_1 = require("../../core/global-counters");
+const task_utils_1 = require("../../utils/task-utils");
+const next_steps_1 = require("../../core/next-steps");
+const readline_1 = require("readline");
+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 spec_skeleton_1 = require("../../core/spec-skeleton");
+const questions_1 = require("../../core/questions");
+const pipeline_engine_1 = require("../../core/pipeline-engine");
+const agent_adapter_1 = require("../../core/agent-adapter");
+const git_integration_1 = require("../../core/git-integration");
+const cleanup_1 = require("../cleanup");
+const unified_config_1 = require("../../core/unified-config");
+const ui_verify_1 = require("../../core/ui-verify");
+// v8.3.125+: 公共同义词扩展模块（从 split.ts 提取，供全链路使用）
+const synonyms_1 = require("../../utils/synonyms");
+const unit_context_assembler_1 = require("../../core/unit-context-assembler");
+/**
+ * 将 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|api/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'],
+            'frontend': ['admin-web', 'h5-mobile', 'frontend'],
+            '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. v7.4.2+: 无法匹配时警告并跳过，不保留非标准端名
+        logger_1.logger.warn(`   ⚠️  非标准端名 "${s}"，无法映射到 CONSTITUTION.md 标准端名 ${standardPlatforms.join('/')}`);
+        logger_1.logger.warn(`      已跳过该端，请检查 AI 输出的 scope 字段`);
+    }
+    return result.length > 0 ? result : standardPlatforms;
+}
+/** 将名称转为目录安全的短 slug（2-4 词）
+ * v8.3.77+: 优先提取英文/数字片段，不再直接去掉中文
+ */
+function slugify(name) {
+    // 优先提取连续的英文/数字片段（如 "User管理" → "User"）
+    const latinMatches = name.match(/[a-zA-Z0-9]+/g);
+    if (latinMatches && latinMatches.length > 0) {
+        return latinMatches.slice(0, 3).join('-').toLowerCase();
+    }
+    // 完全没有英文/数字 → 生成短 hash 作为 fallback
+    const hash = Math.abs(name.split('').reduce((a, c) => a * 31 + c.charCodeAt(0), 7)).toString(36);
+    return hash.slice(0, 6);
+}
+/** 从 AI 返回的任务中提取 topic，多层 fallback（v8.3.77+） */
+function extractTopic(task) {
+    // 1. 优先使用 AI 提供的合法 topic（英文短横线格式）
+    if (task.topic && /^[a-z0-9-]+$/.test(task.topic)) {
+        return task.topic;
+    }
+    // 2. 尝试从 functionalUnit 提取英文片段
+    if (task.functionalUnit) {
+        const latin = task.functionalUnit.match(/[a-zA-Z0-9]+/g);
+        if (latin && latin.length > 0) {
+            return latin.slice(0, 3).join('-').toLowerCase();
+        }
+    }
+    // 3. 尝试从 name 提取英文片段
+    if (task.name) {
+        const latin = task.name.match(/[a-zA-Z0-9]+/g);
+        if (latin && latin.length > 0) {
+            return latin.slice(0, 3).join('-').toLowerCase();
+        }
+    }
+    // 4. fallback 到 hash
+    return slugify(task.name || task.functionalUnit || 'task');
+}
+/**
+ * 生成子任务全局唯一 ID
+ * 格式: Task-{父任务ID}-{端名}
+ * 例: Task-001-booking-service, Task-001-h5-mobile
+ */
+function generateSubtaskId(parentTaskId, platform) {
+    // v6.49.5+ / v8.3.10+：确定性格式 {taskId}-{platform}，保证全项目唯一
+    // 因为每个任务每个端只有一个子任务，所以 {taskId}-{platform} 已经唯一
+    return `Task-${parentTaskId}-${platform}`;
+}
+/** 拆分约束常量（简化版：每个功能单元按涉及的端拆分，每端1个子任务） */
+const SPLIT_RULES = {
+    maxTasksPerIteration: 20, // 单次迭代总任务数上限
+    maxTasksPerUnit: 3, // 每个功能单元最多任务数
+};
+function promptUser(question) {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(`${question} `, answer => { rl.close(); resolve(answer.trim()); });
+    });
+}
+async function detectPlatforms(iterationDir, specified) {
+    if (specified)
+        return specified.split(',').map(p => p.trim()).filter(Boolean);
+    // 1. 优先从 CONSTITUTION.md「端列表」章节读取（v6.46.0+ 显式声明）
+    const platforms = await (0, spec_paths_1.parsePlatformList)();
+    if (platforms.length > 0)
+        return platforms;
+    // v8.3.32 修复：默认不再硬编码 ['web']，返回空数组并提示用户配置
+    logger_1.logger.warn(`⚠️ CONSTITUTION.md 中未找到「端列表」或工程标识表格`);
+    logger_1.logger.warn(`   请先在 CONSTITUTION.md 中配置「项目信息」表格（含工程标识列）`);
+    logger_1.logger.warn(`   或在 .speccore/PROJECT.yaml 中配置 platforms 字段`);
+    return [];
+}
+async function preSplitGate(iterationDir) {
+    const items = [];
+    const specDir = (0, path_1.join)(iterationDir, '020-specs');
+    // 检查全局 FUNCTION_MAP.md（警告级）
+    // v8.3.220+: 降级为 warn——功能单元的权威来源是 010-requirements/features/ 目录（doc2spec --split 产出），
+    // FUNCTION_MAP 仅作「功能×端映射」参考。split 的 prompt 构建已有多级回退（FUNCTION_MAP → ANALYSIS.md → features/）。
+    const funcMapPath = (0, path_1.join)(specDir, spec_paths_1.GLOBAL_SPECS_DIR, 'FUNCTION_MAP.md');
+    const funcMapExists = await (0, fs_extra_1.pathExists)(funcMapPath);
+    let funcMapIsSkeleton = false;
+    if (funcMapExists) {
+        const content = await (0, fs_extra_1.readFile)(funcMapPath, 'utf-8');
+        funcMapIsSkeleton = content.includes('<!-- SPEC-SKELETON -->') || content.trim().length < 100;
+    }
+    items.push({
+        path: funcMapPath,
+        name: 'FUNCTION_MAP.md',
+        purpose: '功能单元×端映射参考（权威来源为 010-requirements/features/ 目录）',
+        impact: '缺失或不完整时仅作提示，split 以 features/ 目录为准拆分，不影响任务生成',
+        exists: funcMapExists,
+        isSkeleton: funcMapIsSkeleton,
+        level: 'warn',
+    });
+    // 检查全局 REQUIREMENT.md（阻塞级——taskify 的核心需求上下文，骨架则无法拆分）
+    const reqPath = (0, path_1.join)(specDir, spec_paths_1.GLOBAL_SPECS_DIR, 'REQUIREMENT.md');
+    const reqExists = await (0, fs_extra_1.pathExists)(reqPath);
+    let reqIsSkeleton = false;
+    if (reqExists) {
+        const content = await (0, fs_extra_1.readFile)(reqPath, 'utf-8');
+        reqIsSkeleton = content.includes('<!-- SPEC-SKELETON -->') || content.trim().length < 100;
+    }
+    items.push({
+        path: reqPath,
+        name: 'REQUIREMENT.md',
+        purpose: '本迭代的完整需求规格，包含功能模块清单和验收标准（taskify 拆分任务的核心依据）',
+        impact: '缺失或仍为骨架时，AI 拆分缺少需求上下文，会拆出无意义任务（如把「写作要求」当功能模块）',
+        exists: reqExists,
+        isSkeleton: reqIsSkeleton,
+        level: 'block',
+    });
+    // v8.3.221+: 检查全局 ANALYSIS.md（阻塞级——功能分析，骨架说明 analyze 未落盘）
+    // v8.3.248+: 模块级回退——v8.3.238 后 analyze 指示 AI 把 ANALYSIS.md 写在 {feature}/overview/ 下
+    // （全局 overview 只留索引类文档），若仍硬性要求全局文件，新流程将永远阻塞无法拆分。
+    // 全局缺失/骨架时，任一功能模块的 overview/ANALYSIS.md 非骨架即视为分析已落盘。
+    const analysisGatePath = (0, path_1.join)(specDir, spec_paths_1.GLOBAL_SPECS_DIR, 'ANALYSIS.md');
+    let analysisGateExists = await (0, fs_extra_1.pathExists)(analysisGatePath);
+    let analysisGateIsSkeleton = false;
+    if (analysisGateExists) {
+        const ac = await (0, fs_extra_1.readFile)(analysisGatePath, 'utf-8');
+        analysisGateIsSkeleton = ac.includes('<!-- SPEC-SKELETON -->') || ac.trim().length < 100;
+    }
+    if (!analysisGateExists || analysisGateIsSkeleton) {
+        try {
+            const fList = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+            for (const f of fList) {
+                const fAnalysisPath = (0, path_1.join)(specDir, f, 'overview', 'ANALYSIS.md');
+                if (!(await (0, fs_extra_1.pathExists)(fAnalysisPath)))
+                    continue;
+                const c = await (0, fs_extra_1.readFile)(fAnalysisPath, 'utf-8');
+                if (!c.includes('<!-- SPEC-SKELETON -->') && c.trim().length >= 100) {
+                    analysisGateExists = true;
+                    analysisGateIsSkeleton = false;
+                    break;
+                }
+            }
+        }
+        catch { /* 回退失败保持原判定 */ }
+    }
+    items.push({
+        path: analysisGatePath,
+        name: 'ANALYSIS.md',
+        purpose: '需求功能分析（功能点清单 F-xx），taskify 拆分任务的输入之一',
+        impact: '仍为骨架说明 analyze 阶段未落盘，拆分会遗漏功能点',
+        exists: analysisGateExists,
+        isSkeleton: analysisGateIsSkeleton,
+        level: 'block',
+    });
+    // 检查功能模块级文档（警告级）
+    const features = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+    for (const feature of features) {
+        const featureReqPath = (0, path_1.join)(specDir, feature, 'overview', 'REQUIREMENT.md');
+        const featureReqExists = await (0, fs_extra_1.pathExists)(featureReqPath);
+        let featureReqIsSkeleton = false;
+        if (featureReqExists) {
+            const content = await (0, fs_extra_1.readFile)(featureReqPath, 'utf-8');
+            featureReqIsSkeleton = content.includes('<!-- SPEC-SKELETON -->') || content.trim().length < 100;
+        }
+        items.push({
+            path: featureReqPath,
+            name: `${feature}/overview/REQUIREMENT.md`,
+            purpose: `功能模块「${feature}」的完整需求（合并各端视角）`,
+            impact: `缺失时，execute 阶段 AI 读不到「${feature}」的详细需求，可能实现不完整`,
+            exists: featureReqExists,
+            isSkeleton: featureReqIsSkeleton,
+            level: 'warn',
+        });
+    }
+    const blockers = items.filter(i => i.level === 'block' && (!i.exists || i.isSkeleton));
+    const warnings = items.filter(i => i.level === 'warn' && (!i.exists || i.isSkeleton));
+    return { pass: blockers.length === 0, blockers, warnings };
+}
+function printPreSplitReport(iterationDir, blockers, warnings) {
+    logger_1.logger.info('');
+    logger_1.logger.info('╔══════════════════════════════════════════════════════════════╗');
+    logger_1.logger.info('║  Split 前置检查报告                                          ║');
+    logger_1.logger.info('╚══════════════════════════════════════════════════════════════╝');
+    if (blockers.length > 0) {
+        logger_1.logger.error(`\n🔴 阻塞项 (${blockers.length} 个) — 必须修复后才能拆分：`);
+        for (const b of blockers) {
+            logger_1.logger.error(`\n   📄 ${b.name}`);
+            logger_1.logger.error(`      路径: ${(0, path_1.relative)(iterationDir, b.path)}`);
+            logger_1.logger.error(`      作用: ${b.purpose}`);
+            logger_1.logger.error(`      影响: ${b.impact}`);
+            if (!b.exists) {
+                logger_1.logger.error(`      状态: ❌ 文件缺失`);
+            }
+            else if (b.isSkeleton) {
+                logger_1.logger.error(`      状态: ⚠️  仍为骨架（待 AI 填充）`);
+            }
+        }
+    }
+    if (warnings.length > 0) {
+        logger_1.logger.warn(`\n🟡 警告项 (${warnings.length} 个) — 建议修复：`);
+        for (const w of warnings) {
+            logger_1.logger.warn(`\n   📄 ${w.name}`);
+            logger_1.logger.warn(`      路径: ${(0, path_1.relative)(iterationDir, w.path)}`);
+            logger_1.logger.warn(`      作用: ${w.purpose}`);
+            logger_1.logger.warn(`      影响: ${w.impact}`);
+            if (!w.exists) {
+                logger_1.logger.warn(`      状态: ❌ 文件缺失`);
+            }
+            else if (w.isSkeleton) {
+                logger_1.logger.warn(`      状态: ⚠️  仍为骨架（待 AI 填充）`);
+            }
+        }
+    }
+    logger_1.logger.info('');
+    logger_1.logger.info('💡 修复建议：');
+    logger_1.logger.info('   运行 speccore analyze -I <迭代名> --apply');
+    logger_1.logger.info('   让 AI 补充缺失的分析产物，然后再执行 split');
+}
+async function iterationTaskifyCommand(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);
+                // v8.3.160+: 默认步骤隔离模式
+                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('');
+                    // v8.3.160+: 步骤隔离模式输出标记 + 子 Agent 激活
+                    const nextCmd = `speccore iteration taskify -I ${iter} --resume --pipeline`;
+                    const prompt = await (0, prompt_builder_1.buildPrompt)('split', {
+                        iteration: iter,
+                        // v8.3.160+: 传递步骤级上下文控制
+                        contextType: result.contextType,
+                        contextBudget: result.contextBudget,
+                    });
+                    const output = [
+                        `[SPECCORE_STEP_DONE]`,
+                        `步骤 "${result.nextStepName || result.nextStepId}" 已完成。`,
+                        ``,
+                        `[SPECCORE_NEXT_STEP]`,
+                        `下一步: ${result.nextStepName || result.nextStepId}`,
+                        `请在同一会话继续执行: ${nextCmd}`,
+                        ``,
+                        `[SPECCORE_CONTEXT_SNAPSHOT]`,
+                        JSON.stringify(result.contextSnapshot || {}),
+                        ``,
+                        // v8.3.160+: 子 Agent 激活标记
+                        ...(result.subagent ? [
+                            `[SPECCORE_SESSION_AGENT: ${result.subagent}]`,
+                            `[SPECCORE_CONTEXT_BUDGET: ${result.contextBudget || 12000}]`,
+                            `[SPECCORE_CONTEXT_TYPE: ${result.contextType || 'full'}]`,
+                            ``,
+                        ] : []),
+                        `--- 下一步 Prompt ---`,
+                        typeof prompt === 'string' ? prompt : JSON.stringify(prompt),
+                    ].join('\n');
+                    process.stdout.write(output);
+                    process.exitCode = 10;
+                    return;
+                    // 根据当前步骤生成相应提示
+                    if (result.nextStepId === 'prompt-analysis') {
+                        const prompt = await (0, prompt_builder_1.buildPrompt)('split', { iteration: iter });
+                        // 添加 Pipeline 继续指令
+                        // v8.3.160+: 步骤隔离模式，每步完成后需新会话继续
+                        const finalPrompt = prompt + `\n\n## ⚠️ Pipeline 模式：步骤隔离\n\n` +
+                            `当前是 Split Pipeline 模式。当你通过 --response 写入任务拆分结果后，` +
+                            `CLI 会自动输出 [SPECCORE_STEP_DONE] 标记，提示你在新会话中执行下一步。\n\n` +
+                            `**看到 [SPECCORE_STEP_DONE] 后，请在同一会话继续执行下一步命令**。\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 继续指令
+        // v8.3.160+: 步骤隔离模式，每步完成后需新会话继续
+        const finalPrompt = prompt + `\n\n## ⚠️ Pipeline 模式：步骤隔离\n\n` +
+            `当前是 Split Pipeline 模式。当你通过 --response 写入任务拆分结果后，` +
+            `CLI 会自动输出 [SPECCORE_STEP_DONE] 标记，提示你在新会话中执行下一步。\n\n` +
+            `**看到 [SPECCORE_STEP_DONE] 后，请在同一会话继续执行下一步命令**。\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)() || '';
+        const prompt = await (0, prompt_builder_1.buildPrompt)('split', { iteration: iter });
+        // v8.3.167+: 检测功能模块数量，大项目启用分批拆分
+        let featureBatchHint = '';
+        try {
+            const iterDirForSplit = await (0, context_1.getIterationDir)(iter);
+            if (iterDirForSplit) {
+                const { parseFeatureList } = await Promise.resolve().then(() => __importStar(require('../../core/spec-paths')));
+                const featureList = await parseFeatureList(iterDirForSplit);
+                if (featureList.length > 2) {
+                    logger_1.logger.info(`📦 检测到 ${featureList.length} 个功能模块，启用分批拆分模式`);
+                    featureBatchHint = `\n\n## 📦 功能模块分批拆分（v8.3.167+）\n\n`;
+                    featureBatchHint += `当前迭代包含 ${featureList.length} 个功能模块：${featureList.join('、')}\n\n`;
+                    featureBatchHint += `**分批策略**：\n`;
+                    featureBatchHint += `- 本次只拆分 **1-2 个功能模块**（优先拆分基础模块：认证/配置/数据库）\n`;
+                    featureBatchHint += `- 确保每个模块的拆分质量（任务定义清晰、依赖关系明确）\n`;
+                    featureBatchHint += `- 剩余模块在 JSON 输出后追加续批标记\n\n`;
+                    featureBatchHint += `**续批标记格式**：\n`;
+                    featureBatchHint += `\`\`\`\n[PENDING: 模块A, 模块B, 模块C]\n`;
+                    featureBatchHint += `[SPECCORE_EXEC: speccore iteration taskify --prompt -I ${iter}]\n`;
+                    featureBatchHint += `\`\`\`\n\n`;
+                    featureBatchHint += `**重要**：不要一次性拆分所有模块，确保当前批次质量后再续批。\n`;
+                }
+            }
+        }
+        catch { /* 忽略功能模块检测失败 */ }
+        // v8.3.166+: 输出 subagent 标记（task-decomposer）
+        // v8.3.169+: 尝试通过 Qoder SDK 直接调度子 Agent
+        const promptText = (0, prompt_builder_1.formatPrompt)(prompt) + featureBatchHint;
+        let llmHandled = false;
+        let aiProvider = 'host';
+        try {
+            const { loadConfigWithMeta } = await Promise.resolve().then(() => __importStar(require('../../core/unified-config')));
+            const { config } = await loadConfigWithMeta();
+            aiProvider = config.settings.ai?.provider || 'host';
+        }
+        catch { /* 默认 host */ }
+        // v8.3.196+: 用自配 LLM 生成任务 JSON，成功设 llmHandled（供 llm 优先 / auto 回退复用）
+        const tryLlmTaskify = async () => {
+            try {
+                const { callLlm, resolveAiProviders } = await Promise.resolve().then(() => __importStar(require('../../core/ask-llm')));
+                const providers = await resolveAiProviders('taskify');
+                const llmContent = await callLlm('你是任务拆解专家。请按 prompt 要求拆分任务，只输出 JSON 数组格式的任务列表，不要输出 JSON 以外的文字。', promptText, providers, 4000);
+                if (llmContent) {
+                    options.response = llmContent;
+                    llmHandled = true;
+                    return true;
+                }
+            }
+            catch (e) {
+                logger_1.logger.debug(`[split] 自配 LLM 生成失败: ${e.message}`);
+            }
+            return false;
+        };
+        // llm 优先模式：先用自配 LLM，失败回退宿主
+        if (aiProvider === 'llm') {
+            if (!(await tryLlmTaskify())) {
+                logger_1.logger.warn('⚠️ [llm] 自配 LLM 未生成任务，回退宿主模式');
+            }
+        }
+        if (!llmHandled && !process.stdout.isTTY) {
+            try {
+                const agentCtx = {
+                    subagent: 'task-decomposer',
+                    iteration: iter || '',
+                    contextBudget: 12000,
+                    contextType: 'full',
+                    cwd: process.cwd(),
+                };
+                const dispatchResult = await (0, agent_adapter_1.dispatchSubagent)(agentCtx, promptText);
+                if (dispatchResult && dispatchResult.success) {
+                    logger_1.logger.info(`[split] 子 Agent task-decomposer SDK 调度成功`);
+                    process.stdout.write(`\n[SPECCORE_RESULT] 子 Agent task-decomposer 通过 Qoder SDK 完成执行\n`);
+                    if (dispatchResult.filesChanged && dispatchResult.filesChanged.length > 0) {
+                        process.stdout.write(`📄 文件变更: ${dispatchResult.filesChanged.join(', ')}\n`);
+                    }
+                    // v8.3.212+: SDK 直连真闭环——返回内容自动落盘（复用 --response 流程，设 llmHandled 避免重复输出 prompt）
+                    if (dispatchResult.content && dispatchResult.content.trim()) {
+                        options.response = dispatchResult.content;
+                        llmHandled = true;
+                    }
+                    else {
+                        process.stdout.write(`\n> 请审查结果后手动 speccore iteration taskify --response 写入任务\n`);
+                        process.exitCode = 0;
+                        return;
+                    }
+                }
+                // 宿主 SDK 调度失败（success=false）→ auto 时回退自配 LLM
+                if (aiProvider === 'auto')
+                    await tryLlmTaskify();
+            }
+            catch (e) {
+                logger_1.logger.debug(`[split] SDK 调度尝试失败: ${e.message}`);
+                // 宿主异常 → auto 时回退自配 LLM
+                if (aiProvider === 'auto')
+                    await tryLlmTaskify();
+            }
+        }
+        if (!llmHandled) {
+            const output = [
+                `[SPECCORE_SESSION_AGENT: task-decomposer]`,
+                `[SPECCORE_CONTEXT_BUDGET: 12000]`,
+                `[SPECCORE_CONTEXT_TYPE: full]`,
+                ``,
+                promptText,
+            ].join('\n');
+            process.stdout.write(output);
+            process.exitCode = 10;
+            return;
+        }
+    }
+    // ── 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);
+            // v8.3.160+: 默认步骤隔离模式
+            const stepResult = 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 {
+                    // v8.3.160+: 传递步骤级上下文控制，确保 Pipeline 配置的 budget/type 生效
+                    const promptResult = await (0, prompt_builder_1.buildPrompt)('split', {
+                        iteration: iter,
+                        contextType: stepResult.contextType,
+                        contextBudget: stepResult.contextBudget,
+                    });
+                    nextPrompt = typeof promptResult === 'string' ? promptResult : JSON.stringify(promptResult);
+                }
+                // v8.3.160+: 步骤隔离模式输出标记 + 子 Agent 激活
+                const nextCmd = `speccore iteration taskify -I ${iter} --resume --pipeline`;
+                const output = [
+                    `[SPECCORE_STEP_DONE]`,
+                    `步骤 "${state.currentStep}" 已完成。`,
+                    ``,
+                    `[SPECCORE_NEXT_STEP]`,
+                    `下一步: ${state.currentStep}`,
+                    `请在同一会话继续执行: ${nextCmd}`,
+                    ``,
+                    `[SPECCORE_CONTEXT_SNAPSHOT]`,
+                    JSON.stringify(stepResult.contextSnapshot || {}),
+                    ``,
+                    // v8.3.160+: 子 Agent 激活标记
+                    ...(stepResult.subagent ? [
+                        `[SPECCORE_SESSION_AGENT: ${stepResult.subagent}]`,
+                        `[SPECCORE_CONTEXT_BUDGET: ${stepResult.contextBudget || 12000}]`,
+                        `[SPECCORE_CONTEXT_TYPE: ${stepResult.contextType || 'full'}]`,
+                        ``,
+                    ] : []),
+                    `--- 下一步 Prompt ---`,
+                    nextPrompt,
+                ].join('\n');
+                process.stdout.write(output);
+                process.exitCode = 10;
+            }
+            return;
+        }
+        // 非 Pipeline 模式的 Response 处理
+        // v8.3.4+ 修复：使用 getIterationDir 解析正确路径，避免 Iteration- 前缀重复
+        const iterDirFull = await (0, context_1.getIterationDir)(iter);
+        const iterDir = (0, path_1.join)(iterDirFull, '030-tasks');
+        await (0, fs_extra_1.ensureDir)(iterDir);
+        const backups = [];
+        // v8.3.163+: AI 上下文中禁用 --force（质量门禁和安全限制不可被 AI 自行绕过）
+        const isAiCtx = !process.stdout.isTTY;
+        if (options.force && isAiCtx) {
+            logger_1.logger.error('❌ AI 上下文中禁止使用 --force 参数');
+            logger_1.logger.info('   质量门禁（任务数限制、拆分粒度校验）不可被 AI 自行绕过');
+            logger_1.logger.info('   如需强制继续，请在交互式终端中执行此命令');
+            return;
+        }
+        // v8.3.160+: 智能提取 JSON（支持 JSON 后附带 [PENDING] / [SPECCORE_EXEC] 标记）
+        function extractJsonArray(text) {
+            const result = { json: text };
+            // 提取 [PENDING: ...]
+            const pendingMatch = text.match(/\[PENDING:\s*([^\]]+)\]/);
+            if (pendingMatch)
+                result.pending = pendingMatch[1].trim();
+            // 提取 [SPECCORE_EXEC: ...]
+            const execMatch = text.match(/\[SPECCORE_EXEC:\s*([^\]]+)\]/);
+            if (execMatch)
+                result.exec = execMatch[1].trim();
+            // 提取 JSON 数组（从第一个 [ 到最后一个 ]）
+            const jsonMatch = text.match(/(\[[\s\S]*\])/);
+            if (jsonMatch)
+                result.json = jsonMatch[1];
+            return result;
+        }
+        const extracted = extractJsonArray(options.response);
+        // 尝试解析 AI 返回的 JSON Task 列表
+        try {
+            const tasks = JSON.parse(extracted.json);
+            if (Array.isArray(tasks)) {
+                const allPlatforms = await detectPlatforms(iterDirFull);
+                const sections = [];
+                for (let i = 0; i < tasks.length; i++) {
+                    const task = tasks[i];
+                    // 📌 核心原则校验：同一功能单元内的任务是否应该合并
+                    // 如果 AI 把同一个功能单元拆成过多任务，给出警告
+                    if (i > 0) {
+                        const prevTask = tasks[i - 1];
+                        const sameUnit = (task.functionalUnit && prevTask.functionalUnit &&
+                            task.functionalUnit === prevTask.functionalUnit);
+                        if (sameUnit) {
+                            logger_1.logger.warn(`   ⚠️  同一功能单元 "${task.functionalUnit}" 已有多个任务：`);
+                            logger_1.logger.warn(`      Task ${i}: ${prevTask.name}`);
+                            logger_1.logger.warn(`      Task ${i + 1}: ${task.name}`);
+                            logger_1.logger.warn(`      💡 建议：同一功能单元的不同子模块应该尽量合并为一个任务`);
+                        }
+                    }
+                    // 将 AI JSON 转换为 Section，复用 createTaskFromSection 创建完整目录
+                    const desc = task.description || task.name || '';
+                    const scopeArr = Array.isArray(task.scope) ? task.scope : [];
+                    const scope = scopeArr.join(', ');
+                    const apis = Array.isArray(task.apis) ? task.apis.join('\n') : '';
+                    const acs = Array.isArray(task.acceptanceCriteria) ? task.acceptanceCriteria.join('\n') : '';
+                    let content = desc;
+                    if (scope)
+                        content += `\n\n范围: ${scope}`;
+                    if (apis)
+                        content += `\n\n接口:\n${apis}`;
+                    if (acs)
+                        content += `\n\n验收标准:\n${acs}`;
+                    // v6.69.3+: 将 AI 返回的 scope 简写映射到标准端名
+                    const taskScopePlatforms = normalizeScopePlatforms(scopeArr, allPlatforms);
+                    const section = {
+                        name: task.name || `Task ${i + 1}`,
+                        content,
+                        level: 2,
+                        platform: taskScopePlatforms[0] || undefined,
+                    };
+                    section._complexity = {
+                        estimatedHours: task.estimatedHours || 8,
+                        priority: task.priority || 'medium',
+                    };
+                    section._owner = task.owner || '未分配';
+                    // v8.3.239+: 任务类型收敛为 4 种（与 task-paths.ts TASK_TYPES 对齐）——
+                    // security 按 feature 交付（安全加固是完整交付，威胁分析归入 TECH.md 安全章节），
+                    // performance 按 refactor 执行（性能优化本质是重构）
+                    const rawType = task.type;
+                    let taskType = (rawType && ['feature', 'bugfix', 'refactor', 'research'].includes(rawType)) ? rawType : 'feature';
+                    if (rawType === 'security') {
+                        taskType = 'feature';
+                        logger_1.logger.info(`   🔒 任务「${task.name}」类型 security 收敛为 feature（安全加固按完整交付）`);
+                    }
+                    if (rawType === 'performance') {
+                        taskType = 'refactor';
+                        logger_1.logger.info(`   ⚡ 任务「${task.name}」类型 performance 收敛为 refactor（性能优化按重构执行）`);
+                    }
+                    section._taskType = taskType;
+                    // 保存 topic slug，用于生成任务目录名（v8.3.77+: 多层提取）
+                    section._topic = extractTopic(task);
+                    // 保存 AI 生成的实际内容（用于写入 REQ.md / TECH.md）
+                    if (task.reqContent)
+                        section._reqContent = task.reqContent;
+                    if (task.techContent)
+                        section._techContent = task.techContent;
+                    // v7.4.0+: 保存 AI 生成的 DEV_GUIDE 内容
+                    if (task.devGuideContent)
+                        section._devGuideContent = task.devGuideContent;
+                    if (task.sourceFile)
+                        section._sourceFile = task.sourceFile;
+                    if (task.functionalUnit)
+                        section.functionalUnit = task.functionalUnit;
+                    if (task.reason)
+                        section._reason = task.reason;
+                    if (taskScopePlatforms.length > 0)
+                        section._scopePlatforms = taskScopePlatforms;
+                    sections.push(section);
+                }
+                // v8.3.223+: 过滤骨架质量标准标题泄漏为功能单元名（spec-skeleton 注入的引导标题
+                // 「📋 质量标准（{docName}）」被 AI 当功能单元，产出垃圾任务名如 Task-NNN-requirement-md）
+                const rubricFiltered = sections.filter(s => {
+                    const name = (s.functionalUnit || s.name || '').trim();
+                    return !/^📋\s*质量标准/.test(name) && !/^质量标准\s*（[^）]*）$/.test(name);
+                });
+                if (rubricFiltered.length < sections.length) {
+                    const removed = sections.length - rubricFiltered.length;
+                    logger_1.logger.warn(`   🧹 已过滤 ${removed} 个「质量标准」骨架标题伪功能单元（AI 未删除骨架引导标题）`);
+                    logger_1.logger.warn('     请检查 AI 拆分结果是否覆盖真实功能单元（参考 FUNCTION_MAP.md）');
+                    sections.length = 0;
+                    sections.push(...rubricFiltered);
+                    if (sections.length === 0) {
+                        logger_1.logger.error('   ❌ 过滤后无有效功能单元，拆分中止。请重新拆分并告诉 AI：不要将「质量标准」骨架标题作为功能单元');
+                        return;
+                    }
+                }
+                // v8.3.4+: 校验所有任务的 scope 是否只含标准端名
+                const invalidScopes = [];
+                for (const sec of sections) {
+                    const scopes = sec._scopePlatforms || [];
+                    for (const s of scopes) {
+                        if (!allPlatforms.includes(s))
+                            invalidScopes.push(`任务 "${sec.name}" 的 scope "${s}"`);
+                    }
+                }
+                if (invalidScopes.length > 0) {
+                    logger_1.logger.error(`❌ 发现 ${invalidScopes.length} 个非标准端名，拆分被拒绝：`);
+                    for (const msg of invalidScopes)
+                        logger_1.logger.error(`   ${msg}`);
+                    logger_1.logger.error(`   标准端名: ${allPlatforms.join(', ')}`);
+                    logger_1.logger.info(`   💡 请告诉 AI：scope 必须使用 CONSTITUTION.md 标准端名，禁止 api/web/backend 等简写`);
+                    return;
+                }
+                // v8.3.4+: 功能点覆盖校验 — 对比 FUNCTION_MAP.md 检查是否有遗漏
+                const funcMapPath = (0, path_1.join)(iterDirFull, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'FUNCTION_MAP.md');
+                if (await (0, fs_extra_1.pathExists)(funcMapPath)) {
+                    try {
+                        const fmContent = await (0, fs_extra_1.readFile)(funcMapPath, 'utf-8');
+                        const funcUnits = parseFunctionMap(fmContent, allPlatforms);
+                        if (funcUnits.length > 0) {
+                            const aiUnits = new Set();
+                            for (const t of tasks) {
+                                const unit = t.functionalUnit || t.name;
+                                if (unit)
+                                    aiUnits.add(unit.trim());
+                            }
+                            const missingUnits = [];
+                            for (const u of funcUnits) {
+                                // 模糊匹配：如果 AI 任务中没有功能单元名包含或被包含于 FUNCTION_MAP 中的名称
+                                const matched = [...aiUnits].some(aiu => aiu.toLowerCase().includes(u.name.toLowerCase()) ||
+                                    u.name.toLowerCase().includes(aiu.toLowerCase()));
+                                if (!matched)
+                                    missingUnits.push(u.name);
+                            }
+                            if (missingUnits.length > 0) {
+                                logger_1.logger.warn(`\n   ⚠️  功能点覆盖警告：${missingUnits.length} 个功能单元可能被遗漏`);
+                                for (const mu of missingUnits.slice(0, 5))
+                                    logger_1.logger.warn(`      📌 ${mu}`);
+                                if (missingUnits.length > 5)
+                                    logger_1.logger.warn(`      ... 还有 ${missingUnits.length - 5} 个`);
+                                logger_1.logger.warn(`   💡 建议检查：这些功能点是否已合并到其他任务中？`);
+                                logger_1.logger.warn(`   💡 如确需补充，重新执行 split 并告诉 AI："补充以下功能点: ${missingUnits.slice(0, 3).join(', ')}"`);
+                            }
+                        }
+                    }
+                    catch { }
+                }
+                // 检测已有任务 + 冲突处理
+                const existingTasks = await detectExistingTasks(iterDirFull);
+                if (existingTasks.length > 0 && !options.force) {
+                    logger_1.logger.warn(`   ⚠️  已有 ${existingTasks.length} 个任务: ${existingTasks.slice(0, 5).join(', ')}...`);
+                    logger_1.logger.info('   使用 --force 强制覆盖');
+                    return;
+                }
+                // --force 清理旧任务（避免新旧叠加编号暴增）
+                if (options.force) {
+                    const tasksRoot = (0, path_1.join)(iterDirFull, '030-tasks');
+                    if (await (0, fs_extra_1.pathExists)(tasksRoot)) {
+                        const entries = await (0, fs_extra_1.readdir)(tasksRoot, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (entry.isDirectory()) {
+                                await (0, fs_extra_1.remove)((0, path_1.join)(tasksRoot, entry.name));
+                            }
+                        }
+                        logger_1.logger.info(`   🗑  已清理旧任务目录`);
+                    }
+                }
+                // 🚨 全局任务数硬限制（安全网：防止 AI 输出爆炸）
+                const MAX_TASKS_HARD = SPLIT_RULES.maxTasksPerIteration;
+                if (sections.length > MAX_TASKS_HARD && !options.force) {
+                    logger_1.logger.error(`\n   ❌ 任务数爆炸！AI 输出了 ${sections.length} 个任务（上限 ${MAX_TASKS_HARD}）`);
+                    logger_1.logger.error(`   💡 这说明拆分粒度过细，必须合并。请告诉 AI："任务太多，请合并相关功能，总数控制在 ${MAX_TASKS_HARD} 以内"`);
+                    logger_1.logger.error(`   🔧 如确实需要，使用 --force 跳过检查（不推荐）`);
+                    logger_1.logger.info('\n   ℹ️  如需强制继续，添加 --force 参数');
+                    return;
+                }
+                if (sections.length > MAX_TASKS_HARD && options.force) {
+                    logger_1.logger.warn(`   ⚠️  任务数 ${sections.length} 超出建议上限 ${MAX_TASKS_HARD}，--force 已启用，继续...`);
+                }
+                // v8.3.162+: 逐功能单元×端校验：每个功能单元的每个端最多 3 个任务
+                // 拆分策略：功能单元先按端拆分，每个端内的子任务最多 3 个
+                const MAX_TASKS_PER_UNIT_PLATFORM = 3;
+                const unitPlatformTaskCount = {};
+                let missingFunctionalUnit = 0;
+                // 按 functionalUnit × platform 分组统计
+                for (let i = 0; i < sections.length; i++) {
+                    const task = tasks[i];
+                    const unitName = task.functionalUnit;
+                    const scopes = Array.isArray(task.scope) ? task.scope : [];
+                    if (!unitName) {
+                        missingFunctionalUnit++;
+                        // 未标注功能单元的任务，按 scope 分别计入 __missing__
+                        for (const platform of scopes) {
+                            const key = `__missing__|${platform}`;
+                            unitPlatformTaskCount[key] = (unitPlatformTaskCount[key] || 0) + 1;
+                        }
+                    }
+                    else {
+                        for (const platform of scopes) {
+                            const key = `${unitName}|${platform}`;
+                            unitPlatformTaskCount[key] = (unitPlatformTaskCount[key] || 0) + 1;
+                        }
+                    }
+                }
+                // functionalUnit 缺失警告
+                if (missingFunctionalUnit > sections.length * 0.5) {
+                    logger_1.logger.warn(`   ⚠️  ${missingFunctionalUnit}/${sections.length} 个任务缺少 functionalUnit 字段`);
+                    logger_1.logger.warn(`      💡 AI 未按约束填写功能单元，校验可能不准确`);
+                    logger_1.logger.warn(`      💡 建议重新执行 split，确保 Prompt 包含 functionalUnit 要求`);
+                }
+                // 检查每个功能单元×端的任务数
+                let hasOverSplit = false;
+                for (const [key, count] of Object.entries(unitPlatformTaskCount)) {
+                    if (count > MAX_TASKS_PER_UNIT_PLATFORM) {
+                        if (!hasOverSplit) {
+                            logger_1.logger.error(`\n   ❌ 检测到过度拆分！某些功能单元在单个端内拆出过多任务：`);
+                            hasOverSplit = true;
+                        }
+                        const [unitName, platform] = key.split('|');
+                        const displayUnit = unitName === '__missing__' ? '(未标注功能单元)' : unitName;
+                        logger_1.logger.error(`      📌 "${displayUnit}" 在 "${platform}" 端拆出了 ${count} 个任务（上限 ${MAX_TASKS_PER_UNIT_PLATFORM}）`);
+                    }
+                }
+                if (hasOverSplit) {
+                    logger_1.logger.error(`   💡 核心原则：功能单元先按端拆分，每个端内默认 1 个任务，最多 3 个`);
+                    logger_1.logger.error(`   🔧 建议操作：`);
+                    logger_1.logger.error(`      1. 重新执行 split，并告诉 AI："任务太多，请合并相关功能"`);
+                    logger_1.logger.error(`      2. 或者手动编辑 .speccore/prompts/split-suggestion-${iter}.md，明确要求"每个功能单元的每个端最多拆 2 个任务"`);
+                    logger_1.logger.error(`      3. 如果确实需要这么多任务，使用 --force 跳过检查（不推荐）`);
+                    if (!options.force) {
+                        logger_1.logger.info('\n   ℹ️  如需强制继续，添加 --force 参数');
+                        return;
+                    }
+                    logger_1.logger.warn('   ⚠️  --force 已启用，继续创建所有任务...');
+                }
+                // v8.3.164+: 内容质量校验 — 拦截空壳任务（reqContent/techContent 实质内容不足）
+                // 问题：AI 返回的 reqContent/techContent 虽然有长度，但全是 AI-FILL 占位符和模板
+                const MIN_SUBSTANTIVE_CHARS = 80; // 实质内容最低字符数
+                const MAX_EMPTY_SHELL_RATIO = 0.5; // 空壳任务占比上限
+                let emptyShellCount = 0;
+                const emptyShellTasks = [];
+                for (let i = 0; i < sections.length; i++) {
+                    const sec = sections[i];
+                    const reqContent = sec._reqContent;
+                    const techContent = sec._techContent;
+                    // 计算实质内容字符数（排除 HTML 注释、AI-FILL 标记、空白行、markdown 格式符号）
+                    const calcSubstantive = (text) => {
+                        if (!text || text.trim().length === 0)
+                            return 0;
+                        // 去除 HTML 注释
+                        let cleaned = text.replace(/<!--[\s\S]*?-->/g, '');
+                        // 去除 AI-FILL 标记行
+                        cleaned = cleaned.replace(/AI-FILL[\s\S]*?$/gm, '');
+                        // 去除 markdown 标题符号
+                        cleaned = cleaned.replace(/^#+\s*/gm, '');
+                        // 去除表格分隔符
+                        cleaned = cleaned.replace(/^[\|\-:\s]+$/gm, '');
+                        // 去除空白行
+                        cleaned = cleaned.replace(/^\s*$/gm, '');
+                        // 去除 markdown 列表符号
+                        cleaned = cleaned.replace(/^[-*+]\s+/gm, '');
+                        // 去除代码块标记
+                        cleaned = cleaned.replace(/^```\w*$/gm, '');
+                        // 去除纯英文占位符（如 "TBD", "TODO", "待补充" 等）
+                        cleaned = cleaned.replace(/\b(TBD|TODO|FIXME|HACK|XXX|待补充|待实现|待填写|待完善|待确认|待定)\b/gi, '');
+                        // 计算剩余实质字符（中文字符 + 英文单词）
+                        const cnChars = (cleaned.match(/[\u4e00-\u9fa5]/g) || []).length;
+                        const enWords = (cleaned.match(/[a-zA-Z]{2,}/g) || []).length;
+                        return cnChars + enWords;
+                    };
+                    const reqSubstantive = calcSubstantive(reqContent);
+                    const techSubstantive = calcSubstantive(techContent);
+                    // 判定为空壳：req 和 tech 都缺乏实质内容
+                    if (reqSubstantive < MIN_SUBSTANTIVE_CHARS && techSubstantive < MIN_SUBSTANTIVE_CHARS) {
+                        emptyShellCount++;
+                        emptyShellTasks.push(`"${sec.name}" (req=${reqSubstantive}, tech=${techSubstantive})`);
+                    }
+                }
+                const emptyRatio = sections.length > 0 ? emptyShellCount / sections.length : 0;
+                if (emptyShellCount > 0) {
+                    if (emptyRatio > MAX_EMPTY_SHELL_RATIO) {
+                        logger_1.logger.error(`\n   ❌ 内容质量拦截：${emptyShellCount}/${sections.length} 个任务为空壳（占比 ${Math.round(emptyRatio * 100)}%，上限 ${Math.round(MAX_EMPTY_SHELL_RATIO * 100)}%）`);
+                        logger_1.logger.error(`   💡 空壳任务特征：reqContent/techContent 全是 AI-FILL 占位符、模板内容或 "待补充"`);
+                        logger_1.logger.error(`   🔧 建议操作：`);
+                        logger_1.logger.error(`      1. 重新执行 split，并告诉 AI："请为每个任务生成完整的需求规格和技术方案，不要只输出骨架"`);
+                        logger_1.logger.error(`      2. 或者检查 analyze 阶段的 020-specs/ 是否有足够内容供 split 提取`);
+                        for (const t of emptyShellTasks.slice(0, 5))
+                            logger_1.logger.error(`      • ${t}`);
+                        if (emptyShellTasks.length > 5)
+                            logger_1.logger.error(`      ... 还有 ${emptyShellTasks.length - 5} 个`);
+                        if (!options.force) {
+                            logger_1.logger.info('\n   ℹ️  如需强制继续，添加 --force 参数');
+                            return;
+                        }
+                        logger_1.logger.warn('   ⚠️  --force 已启用，继续创建空壳任务...');
+                    }
+                    else {
+                        logger_1.logger.warn(`\n   ⚠️  内容质量警告：${emptyShellCount}/${sections.length} 个任务为空壳`);
+                        for (const t of emptyShellTasks.slice(0, 3))
+                            logger_1.logger.warn(`      • ${t}`);
+                        if (emptyShellTasks.length > 3)
+                            logger_1.logger.warn(`      ... 还有 ${emptyShellTasks.length - 3} 个`);
+                        logger_1.logger.warn(`   💡 这些任务将在 execute 阶段依赖 AI 现场生成内容，可能增加开发时间`);
+                    }
+                }
+                // 交互模式判断：显式 --interactive 或 stdin 是 TTY（--force 时跳过交互，直接执行）
+                const isInteractive = (options.interactive || process.stdin.isTTY) && !options.force;
+                // 非交互模式：显示任务总览摘要
+                if (!isInteractive) {
+                    logger_1.logger.info(`\n   📋 任务总览（共 ${sections.length} 个）：`);
+                    const unitSummary = {};
+                    for (let i = 0; i < tasks.length; i++) {
+                        const unit = tasks[i].functionalUnit || '(未标注)';
+                        if (!unitSummary[unit])
+                            unitSummary[unit] = [];
+                        unitSummary[unit].push(tasks[i].name || `Task ${i + 1}`);
+                    }
+                    for (const [unit, names] of Object.entries(unitSummary)) {
+                        logger_1.logger.info(`      📌 ${unit} (${names.length} 个):`);
+                        for (const n of names)
+                            logger_1.logger.info(`         - ${n}`);
+                    }
+                    logger_1.logger.info('');
+                }
+                // 逐任务交互确认
+                const createdSections = [];
+                for (let i = 0; i < sections.length; i++) {
+                    const sec = sections[i];
+                    const complexity = sec._complexity || {};
+                    const taskType = sec._taskType || 'feature';
+                    const deps = (tasks[i].dependencies || []);
+                    const acs = (tasks[i].acceptanceCriteria || []);
+                    // 展示任务摘要
+                    logger_1.logger.info(`\n   ━━━━ 任务 ${i + 1}/${sections.length} ━━━━`);
+                    logger_1.logger.info(`   📌 ${sec.name}`);
+                    logger_1.logger.info(`   🏷  类型: ${taskType} | 🎯 优先级: ${complexity.priority || 'medium'}`);
+                    if (complexity.estimatedHours)
+                        logger_1.logger.info(`   ⏱ 预估: ${complexity.estimatedHours}h`);
+                    if (deps.length > 0)
+                        logger_1.logger.info(`   🔗 依赖: ${deps.join(', ')}`);
+                    if (acs.length > 0) {
+                        logger_1.logger.info(`   ✅ 验收标准:`);
+                        for (const ac of acs.slice(0, 5))
+                            logger_1.logger.info(`      ${ac}`);
+                    }
+                    // 交互确认（仅确认，调整应回到 AI 对话重新生成方案）
+                    if (isInteractive) {
+                        const answer = await promptUser(`   确认创建？(y/回车确认，n 调整方案):`);
+                        if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
+                            logger_1.logger.info(`   💡 如需调整，请告诉 AI：`);
+                            logger_1.logger.info(`      "把 XX 和 YY 合为一个任务" / "ZZ 任务太大，拆成两个" / "修改工时为 Xh"`);
+                            logger_1.logger.info(`      AI 会参考 .speccore/prompts/split-suggestion-${iter}.md 中的规则重新生成`);
+                            logger_1.logger.info(`      调整后再次执行本命令即可`);
+                            return;
+                        }
+                    }
+                    // 使用保存的 topic slug 生成任务ID
+                    // v8.3.33: 优先使用 functionalUnit 作为 topic，使目录名更有意义
+                    const taskTopic = sec.functionalUnit || sec._topic || slugify(sec.name);
+                    const { id: taskId } = await (0, global_counters_1.nextTaskId)(sec.name, taskTopic);
+                    sec._taskId = taskId;
+                    await createTaskFromSection(iterDirFull, taskId, sec, allPlatforms, taskType, sections);
+                    createdSections.push(sec);
+                    logger_1.logger.info(`   ✅ 创建: ${taskId} - [${taskType}] ${sec.name}`);
+                }
+                if (createdSections.length > 0) {
+                    await generateImpactGraph(iterDirFull, createdSections, allPlatforms);
+                    await updateProjectGraph(iterDirFull, createdSections);
+                    // 生成任务总览报告 → 000-overview/TASK_SUMMARY.md
+                    const summaryMd = await generateTaskSummary(iterDirFull, tasks, createdSections);
+                    logger_1.logger.info(`   📊 任务总览 → 000-overview/task-summaries/TASK_SUMMARY-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 16)}.md`);
+                    // 输出报告到 stdout，供宿主 AI 展示给用户
+                    process.stdout.write('\n[SPECCORE_TASK_SUMMARY]\n');
+                    process.stdout.write(summaryMd);
+                    process.stdout.write('\n[/SPECCORE_TASK_SUMMARY]\n');
+                    // 输出下一步操作标记：引导宿主 AI 对每个 Task 执行 analyze --task
+                    outputAnalyzeTaskHints(iter, createdSections);
+                }
+                logger_1.logger.success(`✅ 创建了 ${createdSections.length}/${sections.length} 个任务（${sections.length - createdSections.length} 个跳过）`);
+                // v8.3.160+: 检测是否有待拆分的功能模块
+                if (extracted.pending) {
+                    logger_1.logger.info('');
+                    logger_1.logger.info(`📦 还有未拆分的功能模块: ${extracted.pending}`);
+                    logger_1.logger.info(`   继续拆分: speccore iteration taskify --prompt -I ${iter}`);
+                    if (extracted.exec) {
+                        process.stdout.write(`\n[SPECCORE_EXEC: ${extracted.exec}]\n`);
+                    }
+                }
+            }
+            else {
+                logger_1.logger.warn('AI 返回格式非数组，将作为 Markdown 写入 REQUIREMENT.md');
+                const reqPath = (0, path_1.join)(iterDir, 'REQUIREMENT.md');
+                const bk = await (0, task_utils_1.backupWithTimestamp)(reqPath);
+                if (bk) {
+                    backups.push(bk);
+                    logger_1.logger.info(`   📦 已备份: ${(0, path_1.basename)(bk)}`);
+                }
+                await (0, fs_extra_1.writeFile)(reqPath, options.response);
+            }
+        }
+        catch {
+            const reqPath = (0, path_1.join)(iterDir, 'REQUIREMENT.md');
+            const bk = await (0, task_utils_1.backupWithTimestamp)(reqPath);
+            if (bk) {
+                backups.push(bk);
+                logger_1.logger.info(`   📦 已备份: ${bk.split('/').pop()}`);
+            }
+            await (0, fs_extra_1.writeFile)(reqPath, options.response);
+        }
+        // v7.4.0+: 从 AI 输出中提取疑问并持久化
+        const extractedQs = (0, questions_1.extractQuestionsFromText)(options.response);
+        if (extractedQs.length > 0) {
+            await (0, questions_1.writeQuestions)({ command: 'split', scope: iter }, extractedQs);
+        }
+        logger_1.logger.success('✅ 任务已创建');
+        // 备份汇总
+        if (backups.length > 0) {
+            logger_1.logger.info('');
+            logger_1.logger.info(`📦 备份文件 (${backups.length} 个):`);
+            for (const bp of backups) {
+                logger_1.logger.info(`   ${bp}`);
+            }
+            logger_1.logger.info('   💡 如不再需要可手动删除');
+        }
+        // 自动刷新知识图谱（v6.49.10+）
+        try {
+            const { refreshKnowledgeGraph } = await Promise.resolve().then(() => __importStar(require('../../core/knowledge-graph')));
+            await refreshKnowledgeGraph(process.cwd(), iter);
+            logger_1.logger.info('🧠 知识图谱已刷新');
+        }
+        catch { }
+        return;
+    }
+    // 命令前索引新鲜度检查（非阻塞）
+    await (0, index_guard_1.warnIfIndexStale)(process.cwd(), 'split', options.iteration);
+    const spinner = new logger_1.Spinner('Splitting requirements into tasks');
+    spinner.start();
+    try {
+        const iteration = await (0, context_1.getDefaultIteration)(options.iteration);
+        if (!iteration) {
+            spinner.fail('No active iteration found. Please specify --iteration or create one first.');
+            return;
+        }
+        const iterationDir = await (0, context_1.getIterationDir)(iteration);
+        // v8.3.19+: Split 前置检查 — 确保分析产物完整后再拆分
+        if (!options.prompt && !options.response) {
+            const { pass, blockers, warnings } = await preSplitGate(iterationDir);
+            if (!pass || warnings.length > 0) {
+                spinner.stop();
+                printPreSplitReport(iterationDir, blockers, warnings);
+                if (!pass) {
+                    if (!options.interactive && !options.strict) {
+                        logger_1.logger.info('');
+                        logger_1.logger.info('🤖 自动模式：请先补充分析产物后再拆分');
+                        logger_1.logger.info('   命令: speccore analyze -I <迭代名> --apply');
+                    }
+                    else {
+                        logger_1.logger.error('\n⛔ 拆分被拒绝：存在阻塞项，请先补充分析产物');
+                    }
+                    return;
+                }
+                // 只有警告，没有阻塞
+                if (options.interactive || options.strict) {
+                    const proceed = await promptUser('\n仍要继续拆分？[y/N] ');
+                    if (!proceed || proceed.toLowerCase() !== 'y') {
+                        logger_1.logger.info('已取消拆分');
+                        return;
+                    }
+                }
+                else {
+                    logger_1.logger.info('\n🤖 自动模式：跳过警告，继续拆分');
+                }
+                spinner.start();
+            }
+        }
+        // v6.76.0+: 变更检测 — 检查 020-specs/ 是否比 Task/ 更新
+        if (!options.ignoreSpecsUpdate && !options.prompt && !options.response) {
+            const { detectSpecChangesBeforeSplit, printChangeDetection } = await Promise.resolve().then(() => __importStar(require('../../core/change-detector')));
+            const changeResult = await detectSpecChangesBeforeSplit(iterationDir);
+            printChangeDetection(changeResult, '拆分前检测');
+        }
+        // ── v6.49.13+: 模块驱动拆分 — CLI 按功能模块×端创建任务目录，AI 只填充内容 ──
+        if (!options.prompt && !options.response) {
+            const moduleDrivenResult = await tryModuleDrivenSplit(iteration, iterationDir, options);
+            if (moduleDrivenResult) {
+                return;
+            }
+        }
+        // ── 1. 检查 ANALYSIS.md + AI 智能拆分建议 ──
+        // v8.3.249+: reqContent2/reqContent2Aggregated 提升到块外声明，供下方实际拆分源复用
+        let reqContent2 = '';
+        let reqContent2Aggregated = false;
+        const analysisPathNew = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'ANALYSIS.md');
+        const analysisPathOld = (0, path_1.join)(iterationDir, '020-specs', 'ANALYSIS.md');
+        const analysisPath = await (0, fs_extra_1.pathExists)(analysisPathNew) ? analysisPathNew : analysisPathOld;
+        if (await (0, fs_extra_1.pathExists)(analysisPath)) {
+            const analysis = await (0, fs_extra_1.readFile)(analysisPath, 'utf-8');
+            const blockerLines = analysis.split(/\r?\n/).filter(l => l.includes('🔴') || l.includes('🚫') || l.toLowerCase().includes('blocker'));
+            if (blockerLines.length > 0) {
+                spinner.stop();
+                logger_1.logger.warn(`\n⚠️  ANALYSIS.md 检测到 ${blockerLines.length} 个阻断项:`);
+                for (const line of blockerLines.slice(0, 5)) {
+                    logger_1.logger.warn(`   ${line.trim().slice(0, 80)}`);
+                }
+                // 自动模式不询问用户，直接继续；交互模式才确认
+                if (options.interactive || options.strict) {
+                    const proceed = await promptUser('\n仍要继续拆分？[y/N] ');
+                    if (!proceed || proceed.toLowerCase() !== 'y') {
+                        logger_1.logger.info('已取消拆分');
+                        return;
+                    }
+                }
+                else {
+                    logger_1.logger.info('   ℹ️  自动模式：跳过阻断项确认，继续拆分（疑问记录到 .speccore/questions/）');
+                }
+                spinner.start();
+            }
+            // 生成 AI 智能拆分上下文（含完整 Spec 上下文 + 粒度规则）
+            const promptsDir = (0, path_1.join)('.speccore', 'prompts');
+            await (0, fs_extra_1.ensureDir)(promptsDir);
+            // 读取 CONSTITUTION.md（技术宪法）
+            const constitutionPath = (0, path_1.join)('.speccore', 'CONSTITUTION.md');
+            let constitutionContent = '';
+            if (await (0, fs_extra_1.pathExists)(constitutionPath)) {
+                constitutionContent = await (0, fs_extra_1.readFile)(constitutionPath, 'utf-8');
+            }
+            // 读取 020-specs/ 全部文件（完整上下文）
+            const specDir2 = (0, path_1.join)(iterationDir, '020-specs');
+            // REQUIREMENT.md 从 overview/ 读取
+            const reqPath2 = (0, path_1.join)(specDir2, spec_paths_1.GLOBAL_SPECS_DIR, 'REQUIREMENT.md');
+            if (await (0, fs_extra_1.pathExists)(reqPath2)) {
+                reqContent2 = await (0, fs_extra_1.readFile)(reqPath2, 'utf-8');
+            }
+            // v8.3.160+: 如果全局 REQUIREMENT.md 为空/骨架，从各功能模块 overview/REQUIREMENT.md 聚合
+            // v8.3.249+: 增加陈旧检测——聚合文档不含当前 features 单元名时视为过期，强制重新聚合。
+            // 此前仅按空/骨架判断，旧聚合文档与新切分单元不同步时 taskify 用陈旧数据拆分，
+            // 漏掉新单元（--modules 指定新单元也匹配不到任何 section，反而全量拆分）。
+            let reqContent2IsStale = false;
+            if (reqContent2 && reqContent2.trim().length >= 200 && !reqContent2.includes('<!-- SPEC-SKELETON -->')) {
+                const featuresAll = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+                for (const feature of featuresAll) {
+                    if (!reqContent2.includes(feature)) {
+                        reqContent2IsStale = true;
+                        break;
+                    }
+                }
+            }
+            if (!reqContent2 || reqContent2.trim().length < 200 || reqContent2.includes('<!-- SPEC-SKELETON -->') || reqContent2IsStale) {
+                const featureReqParts = [];
+                const features = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+                for (const feature of features) {
+                    const featureReqPath = (0, path_1.join)(specDir2, feature, 'overview', 'REQUIREMENT.md');
+                    if (await (0, fs_extra_1.pathExists)(featureReqPath)) {
+                        const content = await (0, fs_extra_1.readFile)(featureReqPath, 'utf-8');
+                        if (content.trim().length > 100 && !content.includes('<!-- SPEC-SKELETON -->')) {
+                            featureReqParts.push(`# ${feature}\n\n${content.trim()}`);
+                        }
+                    }
+                }
+                if (featureReqParts.length > 0) {
+                    reqContent2 = featureReqParts.join('\n\n---\n\n');
+                    reqContent2Aggregated = true;
+                }
+            }
+            const specContents = [];
+            // v8.3.21+: 读取全局层文档（overview/ 下）
+            const overviewDir = (0, path_1.join)(specDir2, spec_paths_1.GLOBAL_SPECS_DIR);
+            if (await (0, fs_extra_1.pathExists)(overviewDir)) {
+                const overviewFiles = await (0, fs_extra_1.readdir)(overviewDir, { withFileTypes: true });
+                for (const f of overviewFiles) {
+                    if (!f.name.endsWith('.md'))
+                        continue;
+                    const fp = (0, path_1.join)(overviewDir, f.name);
+                    const content = await (0, fs_extra_1.readFile)(fp, 'utf-8');
+                    if (content.trim().length > 50 && !content.trim().match(/^#+\s*待填充|^<!--\s*AI-FILL/m)) {
+                        specContents.push({ name: f.name, content });
+                    }
+                }
+            }
+            // v8.3.21+: 读取各功能模块下的文档（overview/ + 各端/）
+            const features = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+            for (const feature of features) {
+                const featureDir = (0, path_1.join)(specDir2, feature);
+                if (!await (0, fs_extra_1.pathExists)(featureDir))
+                    continue;
+                const entries = await (0, fs_extra_1.readdir)(featureDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || entry.name.startsWith('.'))
+                        continue;
+                    const subDir = (0, path_1.join)(featureDir, entry.name);
+                    const subFiles = await (0, fs_extra_1.readdir)(subDir, { withFileTypes: true });
+                    for (const sf of subFiles) {
+                        if (!sf.name.endsWith('.md'))
+                            continue;
+                        const fp = (0, path_1.join)(subDir, sf.name);
+                        const content = await (0, fs_extra_1.readFile)(fp, 'utf-8');
+                        if (content.trim().length > 50 && !content.trim().match(/^#+\s*待填充|^<!--\s*AI-FILL/m)) {
+                            specContents.push({ name: `${feature}/${entry.name}/${sf.name}`, content });
+                        }
+                    }
+                }
+            }
+            // 读取类型文档分析（020-specs/{bugs,refactors,research}/）
+            for (const typeDir of ['bugs', 'refactors', 'research']) {
+                const typeDirPath = (0, path_1.join)(specDir2, typeDir);
+                if (!(await (0, fs_extra_1.pathExists)(typeDirPath)))
+                    continue;
+                const typeEntries = await (0, fs_extra_1.readdir)(typeDirPath, { withFileTypes: true });
+                for (const te of typeEntries) {
+                    if (!te.isFile() || !te.name.endsWith('.md'))
+                        continue;
+                    const fp = (0, path_1.join)(typeDirPath, te.name);
+                    const content = await (0, fs_extra_1.readFile)(fp, 'utf-8');
+                    if (content.trim().length > 50 && !content.trim().match(/^#+\s*待填充|^<!--\s*AI-FILL/m)) {
+                        specContents.push({ name: `${typeDir}/${te.name}`, content });
+                    }
+                }
+            }
+            // 获取标准端名列表（用于 prompt 注入和 scope 规范化）
+            const allPlatforms = await detectPlatforms(iterationDir);
+            // v6.76.0+: 扫描已有 Task 结构（增量拆分）
+            const existingTaskStructure = await scanExistingTaskStructure(iterationDir);
+            // 构建完整 prompt（v6.69.3+: 传入标准端名列表，确保 AI 使用正确的端名）
+            // v6.76.0+: 传入过滤条件，限制拆分范围；传入已有 Task 结构，支持增量拆分
+            const modulesFilter = options.modules ? options.modules.split(',').map(m => m.trim()).filter(Boolean) : undefined;
+            const platformsFilter = options.platforms ? options.platforms.split(',').map(p => p.trim()).filter(Boolean) : undefined;
+            // v8.3.160+: 普通模式下默认使用 task-decomposer，full 上下文类型
+            let splitPrompt = await buildSplitPrompt(iteration, constitutionContent, reqContent2, specContents, allPlatforms, modulesFilter, platformsFilter, existingTaskStructure, iterationDir, 'task-decomposer', 'full');
+            // 注入全局上下文（INDEX + TOC 目录，AI 自主读取）
+            const { loadGlobalContext, formatGlobalContext } = await Promise.resolve().then(() => __importStar(require('../../core/prompt-builder')));
+            const globalCtx = await loadGlobalContext(process.cwd(), 'split');
+            if (globalCtx.indexSummary || globalCtx.toc.length > 0) {
+                splitPrompt += '\n' + formatGlobalContext(globalCtx) + '\n';
+            }
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(promptsDir, `split-suggestion-${iteration}.md`), splitPrompt);
+            logger_1.logger.info(`   🤖 AI 拆分建议 → .speccore/prompts/split-suggestion-${iteration}.md`);
+            logger_1.logger.info(`   📜 上下文: CONSTITUTION + REQUIREMENT + ${specContents.length} 个 Spec 文档`);
+        }
+        else {
+            logger_1.logger.info('   ℹ️ 未找到 ANALYSIS.md，建议先运行 speccore analyze');
+        }
+        const reqFileNew = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, options.file || 'REQUIREMENT.md');
+        const reqFileOld = (0, path_1.join)(iterationDir, '020-specs', options.file || 'REQUIREMENT.md');
+        const reqFile = await (0, fs_extra_1.pathExists)(reqFileNew) ? reqFileNew : reqFileOld;
+        if (!(await (0, fs_extra_1.pathExists)(reqFile))) {
+            spinner.fail(`Requirement file not found: ${reqFile}`);
+            return;
+        }
+        const content = await (0, fs_extra_1.readFile)(reqFile, 'utf-8');
+        // v8.3.249+: 聚合后的最新需求内容（含新切分单元）优先于陈旧聚合文档作为实际拆分源
+        const finalContent = (reqContent2Aggregated && reqContent2) ? reqContent2 : content;
+        let sections = extractSections(finalContent, options.sections);
+        // v6.76.0+: 按功能模块过滤
+        if (options.modules) {
+            const moduleFilters = options.modules.split(',').map(m => m.trim()).filter(Boolean);
+            const beforeCount = sections.length;
+            sections = sections.filter(s => moduleFilters.some(f => s.name.includes(f)));
+            if (sections.length < beforeCount) {
+                logger_1.logger.info(`   🎯 模块过滤: ${beforeCount} → ${sections.length}（只拆分: ${moduleFilters.join(', ')}）`);
+            }
+            if (sections.length === 0) {
+                spinner.fail(`没有匹配 "${options.modules}" 的功能模块，请检查模块名称`);
+                return;
+            }
+        }
+        const platforms = await detectPlatforms(iterationDir, options.platforms);
+        // ── 冲突检测: 检查是否已有 Task 目录 ──
+        const existingTasks = await detectExistingTasks(iterationDir);
+        if (existingTasks.length > 0 && !options.force) {
+            spinner.stop();
+            logger_1.logger.warn(`\n⚠️  检测到已有 ${existingTasks.length} 个任务: ${existingTasks.slice(0, 5).join(', ')}${existingTasks.length > 5 ? '...' : ''}`);
+            logger_1.logger.info('   重新 split 会覆盖 TASK.md 中的进度和状态。');
+            logger_1.logger.info('   使用 --force 强制覆盖，或手动删除不需要的任务。\n');
+            return;
+        }
+        // ── 智能分析: 复杂度 + 优先级 + 工时 ──
+        const complexities = sections.map(s => estimateSectionComplexity(s));
+        for (let i = 0; i < sections.length; i++) {
+            sections[i]._complexity = complexities[i];
+        }
+        // ── STAFFING 人员排期 ──
+        const staffing = readStaffing(iterationDir);
+        if (staffing) {
+            logger_1.logger.info(`   👥 STAFFING: ${staffing.map(m => `${m.name}(${m.platforms.join(',')})`).join(', ')}`);
+            for (const section of sections) {
+                if (!section._owner) {
+                    section._owner = autoAssign(section, platforms, staffing);
+                }
+            }
+        }
+        else {
+            logger_1.logger.info('   ℹ️ 未找到 STAFFING.md，人员分配默认为"未分配"');
+        }
+        logger_1.logger.info(`Found ${sections.length} sections to split`);
+        logger_1.logger.info(`Platforms: ${platforms.join(', ')}`);
+        // ── 预分配任务 ID（确保所有路径使用计数器，避免编号重复） ──
+        for (const section of sections) {
+            const topic = slugify(section.name);
+            const { id: taskId } = await (0, global_counters_1.nextTaskId)(section.name, topic);
+            section._taskId = taskId;
+        }
+        // ── Strict mode: preview + confirm each task's split plan ──
+        if (options.strict) {
+            const approved = await strictSplitPreview(sections, platforms, iterationDir);
+            if (approved.length === 0) {
+                spinner.stop('已取消，未创建任何任务');
+                return;
+            }
+            for (const section of approved) {
+                const taskId = section._taskId;
+                await createTaskFromSection(iterationDir, taskId, section, platforms, section._taskType, approved);
+            }
+            spinner.stop(`✅ 创建了 ${approved.length} 个任务`);
+            // 自动刷新知识图谱（v6.49.10+）
+            try {
+                const { refreshKnowledgeGraph } = await Promise.resolve().then(() => __importStar(require('../../core/knowledge-graph')));
+                await refreshKnowledgeGraph(process.cwd(), iteration);
+                logger_1.logger.info('🧠 知识图谱已刷新');
+            }
+            catch { }
+            return;
+        }
+        if (options.dryRun) {
+            spinner.stop('Dry run complete - no files created');
+            for (const section of sections) {
+                logger_1.logger.info(`  Would create: ${section.name}`);
+            }
+            return;
+        }
+        // ── Interactive mode: preview → adjust → confirm → create ──
+        if (options.interactive) {
+            spinner.stop('任务预览');
+            logger_1.logger.info('');
+            // 依赖关系预览
+            const semanticDeps = detectSemanticDependencies(sections);
+            if (semanticDeps.size > 0) {
+                logger_1.logger.info('🔗 任务间依赖关系:\n');
+                for (const [from, targets] of semanticDeps) {
+                    logger_1.logger.info(`   ${from} 依赖 → ${targets.join(', ')}`);
+                }
+                logger_1.logger.info('');
+            }
+            logger_1.logger.info(`📋 共 ${sections.length} 个任务将被创建:\n`);
+            for (let i = 0; i < sections.length; i++) {
+                const taskId = sections[i]._taskId;
+                const contentPreview = sections[i].content?.split(/\r?\n/)[0]?.slice(0, 60) || '';
+                const c = complexities[i];
+                const owner = sections[i]._owner || '未分配';
+                const deps = semanticDeps.get(taskId);
+                logger_1.logger.info(`  ${taskId} → ${sections[i].name}`);
+                if (contentPreview)
+                    logger_1.logger.info(`       ${contentPreview}`);
+                logger_1.logger.info(`       优先级: ${c.priority} | 工时: ${c.estimatedHours}h | 👤 ${owner}`);
+                if (deps)
+                    logger_1.logger.info(`       🔗 依赖: ${deps.join(', ')}`);
+                logger_1.logger.info(`       平台: ${platforms.join(', ')}`);
+                logger_1.logger.info('');
+            }
+            logger_1.logger.info('💡 你可以：');
+            logger_1.logger.info('  [y] 确认创建全部  [n] 逐一确认  [q] 取消');
+            logger_1.logger.info('');
+            const answer = await promptUser('确认创建？');
+            if (answer?.toLowerCase() === 'q') {
+                logger_1.logger.info('已取消');
+                return;
+            }
+            if (answer?.toLowerCase() === 'n') {
+                logger_1.logger.info('进入逐一确认模式...');
+                let created = 0;
+                for (let i = 0; i < sections.length; i++) {
+                    const taskId = sections[i]._taskId;
+                    const resp = await promptUser(`  创建 ${taskId} - ${sections[i].name}? [y/n/q]`);
+                    if (resp?.toLowerCase() === 'q') {
+                        logger_1.logger.info(`已取消，剩余 ${sections.length - i} 个任务未创建`);
+                        break;
+                    }
+                    if (resp?.toLowerCase() === 'y' || resp === '') {
+                        await createTaskFromSection(iterationDir, taskId, sections[i], platforms, sections[i]._taskType, sections);
+                        created++;
+                        logger_1.logger.info(`    ✅ ${taskId}`);
+                    }
+                    else {
+                        logger_1.logger.info(`    ⏭️  跳过 ${sections[i].name}`);
+                    }
+                }
+                spinner.stop(`创建了 ${created}/${sections.length} 个任务`);
+                if (created > 0) {
+                    await generateImpactGraph(iterationDir, sections.slice(0, created), platforms);
+                    await updateProjectGraph(iterationDir, sections.slice(0, created));
+                    // 自动刷新知识图谱（v6.49.10+）
+                    try {
+                        const { refreshKnowledgeGraph } = await Promise.resolve().then(() => __importStar(require('../../core/knowledge-graph')));
+                        await refreshKnowledgeGraph(process.cwd(), iteration);
+                        logger_1.logger.info('🧠 知识图谱已刷新');
+                    }
+                    catch { }
+                }
+                return;
+            }
+            // Default: create all
+            for (let i = 0; i < sections.length; i++) {
+                const taskId = sections[i]._taskId;
+                await createTaskFromSection(iterationDir, taskId, sections[i], platforms, sections[i]._taskType, sections);
+            }
+            await generateImpactGraph(iterationDir, sections, platforms);
+            await generateEnvExample(iterationDir, sections);
+            await updateProjectGraph(iterationDir, sections);
+            spinner.stop(`✅ 创建了 ${sections.length} 个任务`);
+            (0, next_steps_1.showNextSteps)('split');
+            // v8.3.14+: split 后自动清理旧的时间戳备份（保留 7 天内的）
+            await (0, cleanup_1.cleanupByType)({
+                cwd: process.cwd(),
+                types: ['timestampBackups'],
+                days: 7,
+                silent: true,
+            });
+            // 自动刷新知识图谱（v6.49.10+）
+            try {
+                const { refreshKnowledgeGraph } = await Promise.resolve().then(() => __importStar(require('../../core/knowledge-graph')));
+                await refreshKnowledgeGraph(process.cwd(), iteration);
+                logger_1.logger.info('🧠 知识图谱已刷新');
+            }
+            catch { }
+            return;
+        }
+        // Create tasks（使用预分配的 ID）
+        for (let i = 0; i < sections.length; i++) {
+            const taskId = sections[i]._taskId;
+            await createTaskFromSection(iterationDir, taskId, sections[i], platforms, sections[i]._taskType, sections);
+        }
+        // ── Generate impact graph + risk scores ──
+        await generateImpactGraph(iterationDir, sections, platforms);
+        // ── Generate .env.example for the iteration ──
+        await generateEnvExample(iterationDir, sections);
+        // Update PROJECT_GRAPH.md
+        await updateProjectGraph(iterationDir, sections);
+        // 生成任务总览报告
+        const summaryMd = await generateTaskSummary(iterationDir, [], sections);
+        logger_1.logger.info(`📊 任务总览 → 000-overview/task-summaries/`);
+        spinner.stop(`Created ${sections.length} tasks from requirements`);
+        (0, next_steps_1.showNextSteps)('split');
+        // v8.3.14+: split 后自动清理旧的时间戳备份（保留 7 天内的）
+        await (0, cleanup_1.cleanupByType)({
+            cwd: process.cwd(),
+            types: ['timestampBackups'],
+            days: 7,
+            silent: true,
+        });
+        // 自动刷新知识图谱（v6.49.10+）
+        try {
+            const { refreshKnowledgeGraph } = await Promise.resolve().then(() => __importStar(require('../../core/knowledge-graph')));
+            await refreshKnowledgeGraph(process.cwd(), iteration);
+            logger_1.logger.info('🧠 知识图谱已刷新');
+        }
+        catch { }
+    }
+    catch (error) {
+        spinner.fail(`Split failed: ${error}`);
+        throw error;
+    }
+}
+function extractSections(content, sectionFilter) {
+    const sections = [];
+    let currentPlatform;
+    const lines = content.split(/\r?\n/);
+    let currentSection = null;
+    let currentContent = [];
+    for (const line of lines) {
+        const headerMatch = line.match(/^(#{2,4})\s+(.+)/);
+        if (headerMatch) {
+            if (currentSection) {
+                currentSection.content = currentContent.join('\n');
+                sections.push(currentSection);
+            }
+            currentSection = {
+                name: headerMatch[2].trim(),
+                content: '',
+                level: headerMatch[1].length
+            };
+            // 检测 "## {X}端需求" 父章节，子章节继承此平台
+            const platformMatch = currentSection.name.match(/^(.+)端需求$/);
+            if (platformMatch) {
+                currentPlatform = platformMatch[1];
+                currentSection = null; // 容器章节本身不作为 Task
+                continue;
+            }
+            else if (currentSection.level === 2) {
+                currentPlatform = undefined; // 新的 ## 章节重置平台
+            }
+            currentSection.platform = currentPlatform;
+            while (/端端/.test(currentSection.name))
+                currentSection.name = currentSection.name.replace('端端', '端');
+            currentContent = [];
+        }
+        else if (currentSection) {
+            currentContent.push(line);
+        }
+    }
+    if (currentSection) {
+        currentSection.content = currentContent.join('\n');
+        sections.push(currentSection);
+    }
+    // Filter sections if specified
+    if (sectionFilter) {
+        return sections.filter(s => {
+            const filters = sectionFilter.split(',').map(f => f.trim());
+            return filters.some(f => s.name.includes(f));
+        });
+    }
+    // Filter template noise: skip empty/template placeholder sections
+    return filterTemplateNoise(sections);
+}
+const TEMPLATE_PATTERNS = [
+    // Section types that should NOT become separate tasks
+    /^\d+\.\d+\s*(背景|目标|范围)\s*$/,
+    /^\d+\.\d+\s*(性能|安全|兼容性)\s*$/,
+    /^\d+\.\s*(需求概述|功能需求|非功能需求|验收标准|附录)\s*$/,
+    /^功能模块[一二三四五]\s*$/,
+    // Structural PRD headings (not functional requirements)
+    /^功能优先级$/,
+    /^范围边界$/,
+    /^依赖关系$/,
+    /^术语表$/,
+    /^业务规则$/,
+    /^非功能要求?$/,
+    /^原型参考$/,
+    /^版本历史$/,
+    /^项目概述$/,
+    /^BDD 验收标准$/,
+    // 背景/概述/架构类（非功能内容）
+    /项目背景/,
+    /项目目标/,
+    /系统概述/,
+    /系统架构/,
+    /技术架构/,
+    /整体架构/,
+    /名词解释/,
+    /术语定义/,
+    /参考文献/,
+    /修订记录/,
+    /变更历史/,
+    /文档说明/,
+    /编写说明/,
+    /阅读指南/,
+    /目录$/,
+    // 抽象约束类（不是具体功能）
+    /^约束条件$/,
+    /^假设条件$/,
+    /^设计原则$/,
+    /^总体目标$/,
+    /^建设目标$/,
+    /^业务背景$/,
+    /^技术背景$/,
+    // v8.3.223+: 骨架质量标准引导标题（spec-skeleton 注入，AI 填充时可能未删除）不应成为任务
+    /^📋\s*质量标准/,
+    /^质量标准\s*（[^）]*）$/,
+];
+function filterTemplateNoise(sections) {
+    return sections.filter(s => {
+        // Skip sections matching template patterns
+        for (const pattern of TEMPLATE_PATTERNS) {
+            if (pattern.test(s.name))
+                return false;
+        }
+        // Skip sections with effectively empty content (< 20 meaningful chars = no real substance)
+        const meaningful = (s.content || '').replace(/[\s\n>#*-|]/g, '').length;
+        if (meaningful < 20)
+            return false;
+        // Skip sections without API tables (structural headings)
+        return true;
+    });
+}
+// v8.3.4+: 从迭代目录路径提取迭代名（如 Iteration-011-meeting-upgrade → 011-meeting-upgrade）
+function extractIterationName(iterationDir) {
+    const base = (0, path_1.basename)(iterationDir) || '';
+    return base.replace(/^Iteration-/, '');
+}
+/** 生成带实际配置值的 git-config 内容（v8.3.118+） */
+function buildGitConfigContent(config, platformLabel, taskType, branchTypes) {
+    const branchType = taskType === 'bugfix' ? 'bugfix' : taskType === 'refactor' ? 'refactor' : taskType === 'research' ? 'research' : 'feature';
+    // v8.3.118+: 从全局 branch_types 读取对应类型的前缀/后缀/源分支
+    const typeDef = branchTypes?.[branchType];
+    const hasPrefix = typeDef?.prefix !== undefined && typeDef.prefix !== '';
+    const hasSuffix = typeDef?.suffix !== undefined && typeDef.suffix !== '';
+    const hasSource = typeDef?.source !== undefined && typeDef.source !== '';
+    // v8.3.6+: 空值用注释表示，避免 loadSubtaskGitConfig 误把 "(空)" 当实际值
+    const fmt = (key, val, def) => val !== undefined && val !== '' && String(val) !== 'false'
+        ? `${key}: ${val}`
+        : `# ${key}: ${def}`;
+    // v8.3.118+: 前缀/后缀/源分支优先从 branch_types 读取，其次从 gitConfig 读取
+    const effectiveSource = hasSource ? typeDef.source : (config.defaultBranch || '');
+    return `# 子任务级 Git 配置（${platformLabel}）
+# ─────────────────────────────────────────────────────────────────────────────
+# 配置优先级：子任务 > 迭代级 > 全局 CONSTITUTION.md > 默认值
+# 未配置的字段自动从上级继承，无需全部填写
+# ─────────────────────────────────────────────────────────────────────────────
+
+# === 分支类型与命名（v8.3.120+） ===
+# 分支名格式: {类型}/{前缀}{任务名}{后缀}
+#   {类型}/  = 类型自带（如 hotfix/、feature/）
+#   {前缀}   = 任务名前的前缀（可选，包含分隔符），如 api-、backend_、v2.
+#   {任务名} = 子任务全局唯一 ID，如 Task-001-booking-service
+#   {后缀}   = 任务名后的后缀（可选，包含分隔符），如 -urgent、_review、.beta
+#
+# ⚠️ 注意：前缀/后缀的值请包含你想用的分隔符，代码不再自动添加任何符号
+#
+# 示例 1（- 分隔）: 前缀=api- 后缀=-urgent → hotfix/api-Task-001-urgent
+# 示例 2（_ 分隔）: 前缀=api_ 后缀=_urgent → hotfix/api_Task-001_urgent
+# 示例 3（无分隔）: 前缀=api  后缀=urgent  → hotfix/apiTask-001urgent
+
+# 分支类型: 覆盖默认 feature（可选值: feature / bugfix / hotfix / release / support）
+分支类型: ${branchType}
+
+# 前缀: 任务名前的前缀（可选，包含分隔符），如 api-、backend_、v2.
+${hasPrefix ? `前缀: ${typeDef.prefix}` : `# 前缀: api-`}
+
+# 后缀: 任务名后的后缀（可选，包含分隔符），如 -urgent、_review
+${hasSuffix ? `后缀: ${typeDef.suffix}` : `# 后缀: -urgent`}
+
+# === 源分支（从哪个分支创建）===
+# 默认从全局配置的 default_base 创建，如需覆盖请取消注释：
+${fmt('源分支', effectiveSource, 'main')}
+
+# === 保护分支（禁止直接推送）===
+${config.protectedBranches.map(b => `# - ${b}`).join('\n')}
+
+# === 高级配置（一般不修改）===
+# 分支前缀（旧语义，兼容保留）
+${fmt('分支前缀', config.branchPrefix, '无')}
+
+# 分支格式: 自定义分支名模板（支持变量: {type} {prefix} {taskId} {name} {date} {hash4}）
+${fmt('分支格式', config.branchFormat, '{type}/{prefix}{taskId}')}
+
+# 自动拉取: 创建分支前是否自动 git pull（true / false）
+${fmt('自动拉取', config.autoPull ? 'true' : '', 'false')}
+
+# 远程名称: 远程仓库名称（默认 origin）
+${fmt('远程名称', config.remoteName, 'origin')}
+`;
+}
+async function createTaskFromSection(iterationDir, taskId, section, allPlatforms, taskType = 'feature', allSections) {
+    // taskId 已含 slug（nextTaskId 返回 Task-NNN-slug），直接用
+    const taskDir = (0, path_1.join)(iterationDir, '030-tasks', taskType, taskId);
+    const iterationName = extractIterationName(iterationDir);
+    // v8.3.118+: 读取全局 branch_types，用于生成子任务 git-config
+    const projectConfig = await (0, unified_config_1.loadProjectConfig)();
+    const branchTypes = projectConfig.git.branch_types;
+    // v8.3.36: 提前加载 spec 内容，用于平台推断 + 任务级文件填充
+    const specContents = await loadSpecContents(iterationDir);
+    // 确定任务涉及的端：优先使用 AI 标注的 _scopePlatforms，否则从 020-specs 推断
+    let taskPlatforms;
+    if (section._scopePlatforms && section._scopePlatforms.length > 0) {
+        taskPlatforms = section._scopePlatforms;
+    }
+    else if (section.platform) {
+        taskPlatforms = [section.platform];
+    }
+    else {
+        // v8.3.125+: 使用三层匹配推断平台（替代脆弱的字符串包含匹配）
+        taskPlatforms = [];
+        const sectionFeatureName = section.name.replace(/^\d+(\.\d+)*\s*/, '').trim();
+        for (const platform of allPlatforms) {
+            const bestMatch = findBestSpecMatch(specContents, sectionFeatureName, platform, 'TECH.md');
+            if (bestMatch && bestMatch.score >= 20) {
+                taskPlatforms.push(platform);
+            }
+        }
+        // v8.3.185+: Spec 匹配失败时，用六层端推断机制（显式声明→_matrix→目录→关键词→AI）
+        if (taskPlatforms.length === 0) {
+            const { inferFeaturePlatforms } = await Promise.resolve().then(() => __importStar(require('../../core/platform-inference')));
+            const featureDir = (0, path_1.join)(iterationDir, '010-requirements', 'features', sectionFeatureName);
+            const inference = await inferFeaturePlatforms({
+                featureName: sectionFeatureName,
+                featureDir,
+                allPlatforms,
+            });
+            taskPlatforms = inference.platforms;
+            if (inference.needsConfirm || inference.source === 'ai-required') {
+                logger_1.logger.warn(`   ⚠️  功能「${sectionFeatureName}」端推断置信度 ${inference.confidence}（${inference.source}），建议人工确认 _matrix.md`);
+            }
+        }
+    }
+    const complexity = section._complexity || { estimatedHours: 8, priority: 'medium' };
+    const owner = section._owner || '未分配';
+    const today = new Date().toISOString().split('T')[0];
+    // v8.3.32 修复：020-specs 缺失时给出明确警告
+    const hasSpecContent = Object.keys(specContents).length > 0;
+    if (!hasSpecContent) {
+        logger_1.logger.warn(`   ⚠️  未找到 020-specs/ 分析文档，任务级 REQ.md/TECH.md 将生成空模板`);
+        logger_1.logger.warn(`      建议先运行: speccore analyze -I ${iterationName} --auto`);
+    }
+    // 预生成所有端的子任务 ID（保证同一端在所有文件中 ID 一致）
+    const taskNum = taskId.replace(/^Task-/, '');
+    const subtaskIdMap = new Map();
+    for (const p of taskPlatforms) {
+        subtaskIdMap.set(p, generateSubtaskId(taskNum, p));
+    }
+    // ── 1. 任务目录指引（功能模块分组） ──
+    await (0, fs_extra_1.ensureDir)(taskDir);
+    const isResearch = taskType === 'research';
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, 'README.md'), isResearch
+        ? `# ${section.name}
+
+> 技术调研任务 — 产出调研文档，不产出代码
+
+## 目录结构
+
+\`\`\`
+${taskId}/
+├── .meta/                 ← 任务元信息（feature/type/status/owner）
+├── README.md              ← 本文件（调研任务说明）
+├── _shared/               ← 共享上下文（CONTEXT.md）
+├── 00-specs/              ← 核心规格（REQ.md/TECH.md）
+├── RESEARCH.md            ← 调研报告
+├── COMPARISON.md          ← 方案对比
+└── .issues.md             ← 问题追踪
+\`\`\`
+
+## AI 执行时读取规则
+
+运行 \`speccore execute -t ${taskId}\` 时:
+- 读取 \`00-specs/REQ.md\` — 调研目标
+- 读取 \`_shared/CONTEXT.md\` — 任务上下文
+- 产出写入 \`RESEARCH.md\` 和 \`COMPARISON.md\`
+`
+        : `# ${section.name}
+
+> 功能模块分组 — 聚合相关子任务，共享规格与契约
+
+## 目录结构
+
+\`\`\`
+${taskId}/
+├── .meta/                     ← 任务元信息（feature/type/status/owner）
+├── README.md                  ← 本文件
+├── _shared/                   ← 共享契约（API_CONTRACT.yaml + CONTEXT.md）
+├── 00-specs/                  ← 模块级核心规格（REQ/TECH/SCHEMA/CHANGELOG）
+├── {服务名}/                  ← 后端服务（如 booking-service，v6.49.3+ 平铺架构）
+│   └── {taskId}-{子任务}/     ← 执行单元（.meta/TASK.md + 规格文档）
+├── {端名}/                    ← 前端端（如 h5-mobile/admin-web，v6.49.3+ 平铺架构）
+│   └── {taskId}-{子任务}/     ← 执行单元（.meta/TASK.md + 规格文档 + 前端设计）
+\`\`\`
+
+## 子任务列表
+
+| 子任务 ID | 所属端/服务 | 负责人 | 状态 |
+| :--- | :--- | :--- | :--- |
+${taskPlatforms.map((p) => `| ${subtaskIdMap.get(p)} | ${p} | ${owner} | 🔲 待开发 |`).join('\n')}
+
+## AI 执行时读取规则
+
+运行 \`speccore execute -t ${taskId} --platform {端}\` 时:
+
+### 必读（自动嵌入）
+- \`00-specs/REQ.md\` — 模块需求描述
+- \`00-specs/TECH.md\` — 模块技术方案
+- \`_shared/CONTEXT.md\` — 任务上下文（来源 + 关联）
+- \`_shared/API_CONTRACT.yaml\` — API 契约
+- \`{platform}/{子任务}/TASK.md\` — 子任务详情
+- \`.meta/type\` + \`.meta/status\` — 子任务元信息
+
+### 参考（按需读取）
+- \`020-specs/\` 下的迭代全局文档
+- \`.speccore/GLOBAL/\` 下的全局知识库
+
+### 代码输出位置
+- AI 生成的代码写入 **CONSTITUTION.md/PROJECT.yaml 中声明的源码路径**，不写入迭代目录
+- 子任务目录只存放规格文档（TASK.md/TEST.md/RISK.md 等），不存放代码
+`);
+    // ── 3. 任务级 .meta/（功能单元标识）+ 共享契约 + 核心规格目录 ──
+    await (0, fs_extra_1.ensureDir)((0, path_1.join)(taskDir, '.meta'));
+    const taskFeatureName = section.functionalUnit || section.name || '未分类';
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'feature'), taskFeatureName);
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'type'), taskType);
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'status'), 'todo');
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'owner'), owner);
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'created-at'), today);
+    // v8.3.5+: 写入预估工时到 .meta/estimated-hours，供 plan/状态面板读取
+    const taskHours = section._complexity?.estimatedHours || complexity.estimatedHours || 8;
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.meta', 'estimated-hours'), String(taskHours));
+    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'));
+    // 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);
+    const aiReqContent = section._reqContent;
+    // v8.3.160+: 提升阈值，确保内容质量（200/300 字符起用）
+    // v8.3.160+: 优先从功能模块级 overview/REQUIREMENT.md 提取，回退全局 REQUIREMENT.md
+    const bestReqMatch = findBestSpecMatch(specContents, section.name, undefined, 'REQUIREMENT.md');
+    const analyzeReqContent = bestReqMatch && bestReqMatch.score >= 20
+        ? extractRelevantSection(specContents[bestReqMatch.key], section.name, '需求 功能 业务规则 异常场景 验收标准')
+        : extractRelevantSection(specContents['REQUIREMENT.md'] || '', section.name, '需求 功能 业务规则 异常场景 验收标准');
+    if (aiReqContent && aiReqContent.length > 200) {
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'REQ.md'), `# ${section.name}\n\n${aiReqContent}\n\n## 验收标准\n\n${acItems}\n`);
+    }
+    else if (analyzeReqContent && analyzeReqContent.length > 300) {
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'REQ.md'), `# ${section.name}\n\n> 来源: analyze → REQUIREMENT.md（自动提取）\n\n${analyzeReqContent}\n\n## 验收标准\n\n${acItems}\n`);
+    }
+    else if (section.content && section.content.trim().length > 200) {
+        // v8.3.160+: 第三级回退 — section.content 有实质内容时直接使用
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'REQ.md'), `# ${section.name}\n\n> 来源: split 阶段 section 原始内容\n\n${section.content.trim()}\n\n## 验收标准\n\n${acItems}\n`);
+    }
+    else {
+        // 最终回退：精简骨架 + section.content（即使很短也放入，方便 AI execute 阶段参考）
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'REQ.md'), `# ${section.name}\n\n## 需求描述\n\n${section.content || '（待补充，请根据功能单元描述填充）'}\n\n## 验收标准\n\n${acItems}\n`);
+    }
+    const apiLines = section.content.split(/\r?\n/).filter(l => l.includes('| GET') || l.includes('| POST') || l.includes('| PUT') || l.includes('| DELETE') || l.includes('| PATCH'));
+    const apiDesc = apiLines.length > 0 ? apiLines.map(l => `- ${l.trim()}`).join('\n') : '- 待补充（从 REQ.md 提取接口列表）';
+    const aiTechContent = section._techContent;
+    // 从 analyze TECH.md 提取本任务相关内容
+    const specTechContent = extractTaskTechContent(specContents, section);
+    // v8.3.0+: 从 analyze ANALYSIS.md 补充功能分析内容
+    // v8.3.160+: 优先从功能模块级 overview/ANALYSIS.md 提取，回退全局 ANALYSIS.md
+    const bestAnalysisMatch = findBestSpecMatch(specContents, section.name, undefined, 'ANALYSIS.md');
+    const analyzeAnalysisContent = bestAnalysisMatch && bestAnalysisMatch.score >= 20
+        ? extractRelevantSection(specContents[bestAnalysisMatch.key], section.name, '功能分析 业务流程 数据流 决策逻辑 业务规则')
+        : extractRelevantSection(specContents['ANALYSIS.md'] || '', section.name, '功能分析 业务流程 数据流 决策逻辑 业务规则');
+    // v8.3.160+: 提升阈值，确保内容质量（200/150 字符起用）
+    // TECH.md: 优先 AI 生成 → 回退 analyze 提取 → 回退 section 内容提取 → 回退模板
+    if (aiTechContent && aiTechContent.length > 200) {
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'TECH.md'), `# ${section.name} - 技术方案\n\n${aiTechContent}\n`);
+    }
+    else if (specTechContent && specTechContent.length > 150) {
+        let techBody = `> 来源: analyze → TECH.md（自动提取）\n\n${specTechContent}`;
+        // 追加 ANALYSIS.md 功能分析（如有）
+        if (analyzeAnalysisContent && analyzeAnalysisContent.length > 100) {
+            techBody += `\n\n---\n\n## 功能分析补充\n\n> 来源: analyze → ANALYSIS.md（自动提取）\n\n${analyzeAnalysisContent}`;
+        }
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'TECH.md'), `# ${section.name} - 技术方案\n\n${techBody}\n`);
+    }
+    else {
+        // v8.3.160+: 第三级回退 — 从 section.content 提取技术相关内容
+        const sectionTechExtract = extractRelevantSection(section.content, section.name, '接口 数据 模型 字段 表结构 技术方案 架构 流程');
+        if (sectionTechExtract && sectionTechExtract.length > 100) {
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'TECH.md'), `# ${section.name} - 技术方案\n\n> 来源: split 阶段 section 原始内容（技术相关段落自动提取）\n\n${sectionTechExtract}\n\n## 接口设计\n${apiDesc}\n`);
+        }
+        else {
+            // 最终回退：精简骨架模板（保留接口信息，减少 AI-FILL 占位符数量）
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'TECH.md'), `# ${section.name} - 技术方案
+
+> ⚠️ 本文档由 split 自动生成框架，内容待 AI execute 阶段填充。
+> 参考：_shared/CONTEXT.md、00-specs/REQ.md、020-specs/overview/TECH.md
+
+## 1. 方案概述
+<!-- AI-FILL: 简述本任务的业务背景和技术目标 -->
+
+## 2. 接口设计
+${apiDesc}
+
+### 统一响应格式
+\`\`\`json
+{ "code": 0, "message": "success", "data": {} }
+\`\`\`
+
+## 3. 数据模型
+<!-- AI-FILL: 分析接口参数，设计 Entity/DTO/VO -->
+
+## 4. 核心逻辑
+<!-- AI-FILL: 描述关键业务流程和边界条件 -->
+
+## 5. 测试策略
+- 单元测试覆盖核心 Service 逻辑
+- 接口测试覆盖正常/异常/边界
+- 自动化测试通过后方可提 PR
+`);
+        }
+    }
+    // v7.4.0+: DEV_GUIDE.md 写入
+    // v8.3.0+: 三级回退 — AI split 生成 → analyze DEV_GUIDE.md 提取 → 结构化模板
+    const aiDevGuideContent = section._devGuideContent;
+    const analyzeDevGuideContent = extractTaskDevGuideContent(specContents, section, taskPlatforms);
+    // v8.3.160+: 提升阈值，确保内容质量（200/300 字符起用）
+    if (aiDevGuideContent && aiDevGuideContent.length > 200) {
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'DEV_GUIDE.md'), `# ${section.name} - 开发者实现指南\n\n${aiDevGuideContent}\n`);
+    }
+    else if (analyzeDevGuideContent && analyzeDevGuideContent.length > 300) {
+        // v8.3.0+: 从 analyze DEV_GUIDE.md 提取本任务相关内容
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'DEV_GUIDE.md'), `# ${section.name} - 开发者实现指南\n\n> 任务: ${taskId} | ${section.name}\n> 本文档面向开发者，提供可执行的实现指导。\n> 来源: analyze → DEV_GUIDE.md（自动提取）\n\n${analyzeDevGuideContent}\n\n## 全局开发指南引用\n- 环境/规范/联调 → ../../../overview/DEV_GUIDE.md\n`);
+    }
+    else {
+        // v8.3.160+: 第三级回退 — 从 section.content 提取开发相关内容
+        const sectionDevExtract = extractRelevantSection(section.content, section.name, '步骤 实现 改造 文件 函数 类 接口 验证 测试');
+        if (sectionDevExtract && sectionDevExtract.length > 100) {
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'DEV_GUIDE.md'), `# ${section.name} - 开发者实现指南\n\n> 任务: ${taskId} | ${section.name}
+> 本文档面向开发者，提供可执行的实现指导。
+> 来源: split 阶段 section 原始内容（开发相关段落自动提取）
+
+${sectionDevExtract}
+
+## 全局开发指南引用
+- 环境/规范/联调 → ../../../overview/DEV_GUIDE.md
+`);
+        }
+        else {
+            // 最终回退：结构化骨架模板（AI execute 阶段填充）
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'DEV_GUIDE.md'), `# ${section.name} - 开发者实现指南\n\n> 任务: ${taskId} | ${section.name}\n> 本文档面向开发者，提供可执行的实现指导。\n\n## 1. 本任务改造范围\n\n<!-- AI-FILL: execute 阶段根据 REQ.md 和 TECH.md 填充 -->\n| 类型 | 文件/目录 | 说明 |\n| :--- | :--- | :--- |\n| 新增 | | |\n| 修改 | | |\n| 删除 | | |\n\n## 2. 实施步骤（按依赖排序）\n\n<!-- AI-FILL: Step-by-step 开发步骤，具体到文件/函数级 -->\n- **Step 1**: ...（为什么先做，依赖什么）\n- **Step 2**: ...（依赖 Step 1 的什么产出）\n- ...\n\n## 3. 关键代码指引\n\n<!-- AI-FILL: 核心逻辑的伪代码或改造前后对比 -->\n\n### 3.1 核心改造点 A\n- **文件**: \`xxx.ts\`\n- **改造**: ...\n- **代码示例**:\n  \`\`\`typescript\n  // 改造后\n  \`\`\`\n\n## 4. 接口契约\n\n<!-- AI-FILL: 本任务涉及的前后接口对照 -->\n| 接口 | 路径 | 后端实现 | 前端调用 | 状态 |\n| :--- | :--- | :--- | :--- | :--- |\n\n## 5. 每步验证\n\n<!-- AI-FILL: 每步改完怎么验证 -->\n| 步骤 | 验证命令/操作 | 通过标准 |\n| :--- | :--- | :--- |\n\n## 6. 回滚方案\n\n<!-- AI-FILL: 改坏了怎么回退 -->\n- 数据库: ...\n- 代码: ...\n\n## 7. 已知坑点\n\n<!-- AI-FILL: 常见坑点及解决方式 -->\n- ⚠️ **坑 1**: ...（解决方式）\n- ⚠️ **坑 2**: ...（解决方式）\n\n## 全局开发指南引用\n- 环境/规范/联调 → ../../../overview/DEV_GUIDE.md\n`);
+        }
+    }
+    if (section.content.match(/数据库|数据表|表结构|DDL|ALTER|建表|索引/)) {
+        // v8.3.239+: 三层匹配提取 DDL（兼容 {feature}/overview/TECH.md 嵌套键，旧扁平键取不到 DDL）
+        const bestTechMatch = findBestSpecMatch(specContents, section.name, undefined, 'TECH.md');
+        const schemaMaterial = extractRelevantSection((bestTechMatch && bestTechMatch.score >= 20 ? specContents[bestTechMatch.key] : specContents['TECH.md']) || '', section.name, 'DDL 建表 表结构 索引 CREATE TABLE');
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'SCHEMA.md'), generateSchemaTemplate(section, schemaMaterial));
+    }
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '00-specs', 'CHANGELOG.md'), `# ${section.name} - 变更记录
+
+| 时间 | 版本 | 变更内容 | 变更人 |
+| :--- | :--- | :--- | :--- |
+| ${today} | v1.0 | 初始创建 | CLI |
+`);
+    // API_CONTRACT.yaml 统一放 _shared/
+    // v8.3.239+: 全局契约是单一真相源——已写入时不再覆盖（保留 rate limit/幂等性/版本策略），
+    // section 提取版仅作兜底（全局契约不存在时）
+    if (apiLines.length > 0 && !(await (0, fs_extra_1.pathExists)((0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml')))) {
+        // 从 section 内容提取每个 API 的请求/响应字段
+        const sectionContent = section.content || '';
+        const apiFieldMap = {};
+        for (const l of apiLines) {
+            const parts = l.split('|').map(p => p.trim()).filter(Boolean);
+            const path = parts[1] || '/api/unknown';
+            const apiIdx = sectionContent.indexOf(path);
+            if (apiIdx >= 0) {
+                const after = sectionContent.slice(apiIdx, apiIdx + 800);
+                const fields = [];
+                const fieldRegex = /[`']([a-zA-Z]\w{1,25})[`']\s*[（(]?[：:]?\s*(?:类型[：:])?\s*([\u4e00-\u9fa5A-Za-z]+)/g;
+                let fm;
+                while ((fm = fieldRegex.exec(after)) !== null) {
+                    if (!['api', 'data', 'code', 'message', 'msg', 'status', 'ok', 'err'].includes(fm[1].toLowerCase())) {
+                        fields.push(`${fm[1]}: ${fm[2]}`);
+                    }
+                }
+                if (fields.length > 0)
+                    apiFieldMap[path] = fields.slice(0, 10);
+            }
+        }
+        const contracts = apiLines.map(l => {
+            const parts = l.split('|').map(p => p.trim()).filter(Boolean);
+            const method = (parts[0] || 'GET').toUpperCase();
+            const path = parts[1] || '/api/unknown';
+            const desc = parts[2] || path;
+            let yaml = `  ${path}:\n    ${method}:\n      summary: "${desc}"`;
+            if (apiFieldMap[path]) {
+                yaml += `\n      fields:`;
+                for (const f of apiFieldMap[path]) {
+                    yaml += `\n        - "${f}"`;
+                }
+            }
+            yaml += `\n      responses:\n        "200":\n          description: Success`;
+            return yaml;
+        }).join('\n');
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml'), `# ${section.name} - API Contract\n# Auto-generated from split\n\npaths:\n${contracts}\n`);
+    }
+    // ── 4. 子任务目录（按任务类型差异化） ──
+    // 预加载执行产出模板材料（每个子任务都需要）
+    // v8.3.239+: 材料提取统一走三层匹配——兼容 overview/ 扁平键与 {feature}/overview/ 嵌套键
+    // （新结构下 RISK/DEPS/MONITOR 在功能模块目录，旧结构下在 overview/ 平铺）
+    const extractMaterial = (docName) => {
+        const best = findBestSpecMatch(specContents, section.name, undefined, docName);
+        if (best && best.score >= 20) {
+            return extractRelevantSection(specContents[best.key], section.name);
+        }
+        return extractRelevantSection(specContents[docName] || '', section.name);
+    };
+    const testMaterial = extractMaterial('TEST.md');
+    // v8.3.239+: 分析层 9 份名单无 REVIEW/DEPLOY，提取恒空 → 不再提取，走内容感知模板
+    // （generateReviewChecklist/generateDeployChecklist 保留 material 参数，未来补提取源即可恢复）
+    const riskMaterial = extractMaterial('RISK.md');
+    const depsMaterial = extractMaterial('DEPS.md');
+    const monitorMaterial = extractMaterial('MONITOR.md');
+    // v8.3.239+: 子任务文档按类型裁剪——bugfix 轻量（修缺陷无需部署/监控/前端设计），
+    // refactor 中等（保留风险与组件树，跳过路由/样式/部署/监控），feature 全套
+    const docSet = {
+        hasRisk: taskType !== 'bugfix',
+        hasMonitor: taskType === 'feature',
+        hasDeploy: taskType === 'feature',
+        hasFeDesign: taskType === 'feature', // ROUTES/STATE/STYLE_GUIDE
+        hasComponentTree: taskType !== 'bugfix', // feature/refactor 前端影响面
+        hasAdr: taskType !== 'bugfix',
+    };
+    // ── 4a. research 类型：不创建平台/子任务目录，直接产出调研文档 ──
+    if (isResearch) {
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, 'RESEARCH.md'), `# ${section.name} — 调研报告
+
+## 调研目标
+${section.content}
+
+## 调研结果
+<!-- AI-FILL: 调研发现、技术选型分析 -->
+
+## 推荐方案
+<!-- AI-FILL: 推荐方案及理由 -->
+
+## 风险与建议
+<!-- AI-FILL -->
+`);
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, 'COMPARISON.md'), `# ${section.name} — 方案对比
+
+| 维度 | 方案 A | 方案 B | 方案 C |
+|:---|:---|:---|:---|
+| 技术栈 | | | |
+| 开发成本 | | | |
+| 性能 | | | |
+| 可维护性 | | | |
+| 社区生态 | | | |
+
+## 综合评价
+<!-- AI-FILL -->
+`);
+    }
+    else {
+        // ── 4b. feature/bugfix/refactor：端平铺 → 子任务（v6.49.0+ 统一架构）──
+        // 创建子任务的通用函数
+        const createSubtask = async (subtaskDir, subtaskId, platformName, platformLabel, isBk, hours) => {
+            // .meta/
+            await (0, fs_extra_1.ensureDir)((0, path_1.join)(subtaskDir, '.meta'));
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'type'), taskType);
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'status'), 'todo');
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'owner'), owner);
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'created-at'), today);
+            // v8.3.5+: 子任务工时（按端均分或保持父任务工时）
+            const subHours = complexity.estimatedHours || 8;
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'estimated-hours'), String(subHours));
+            // 功能单元标识（v6.49.2+）：默认取 section 的 functionalUnit 或 section.name
+            const featureName = section.functionalUnit || section.name || '未分类';
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'feature'), featureName);
+            // v8.3.4+: git-config 自动填充 — 读取迭代级/全局级实际配置值写入
+            // v8.3.118+: 传入全局 branch_types，让子任务 git-config 自动填充前缀/后缀/源分支
+            const gitConfig = (0, git_integration_1.loadGitConfig)(iterationName);
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, '.meta', 'git-config'), buildGitConfigContent(gitConfig, platformLabel, section.type, branchTypes));
+            // v6.70.0+: 从 section 提取接口/页面清单用于 TASK.md
+            const apiLines = section.content.split(/\r?\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(/\r?\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}
+
+## 子任务信息
+- **子任务 ID**: \`${subtaskId}\`
+- **所属模块**: \`${taskId}\`
+- **功能单元**: ${featureName}
+- **端**: ${platformName}
+- **负责人**: ${owner}
+- **状态**: 待开发
+- **预计耗时**: ${hours}h
+
+## 共享规格引用
+- REQ.md → ../../../00-specs/REQ.md
+- TECH.md → ../../../00-specs/TECH.md
+- DEV_GUIDE.md → ../../../00-specs/DEV_GUIDE.md
+- API_CONTRACT.yaml → ../../../_shared/API_CONTRACT.yaml
+- CONTEXT.md → ../../../_shared/CONTEXT.md
+- 全局开发指南 → ../../../overview/DEV_GUIDE.md
+
+## 跨端关联
+- **共享能力**: ${sharedCap}
+- **依赖任务**: ${dependsOn}
+- **跨端说明**: ${crossDesc}
+
+## 本任务改造范围（代码级）
+
+<!-- AI-FILL: execute 阶段根据 DEV_GUIDE.md 和 TECH.md 填充具体文件 -->
+| 类型 | 文件/目录 | 说明 |
+| :--- | :--- | :--- |
+| 新增 | | |
+| 修改 | | |
+| 删除 | | |
+
+## 工作清单
+
+### 第一阶段：需求确认
+- [ ] 阅读 00-specs/REQ.md 确认本任务需求范围
+- [ ] 阅读 00-specs/DEV_GUIDE.md 确认改造范围和顺序
+- [ ] 阅读 _shared/API_CONTRACT.yaml 确认接口契约
+- [ ] 阅读 _shared/CONTEXT.md 确认跨端关联
+
+### 第二阶段：技术方案
+- [ ] 阅读 00-specs/TECH.md 确认技术方案
+${isBk ? `- [ ] 设计本端负责的接口（路径/方法/参数/响应/错误码）
+- [ ] 设计数据模型（Entity/DTO/VO/表结构）
+- [ ] 设计业务逻辑流程和边界条件` : `- [ ] 设计本端负责的页面（路由/组件/状态）
+- [ ] 确认 API 调用链（调哪些后端接口）
+- [ ] 设计字段映射和表单校验规则`}
+
+### 第三阶段：开发实施（按依赖排序）
+${isBk ? `- [ ] 实现数据库变更（如有）— 先改表结构
+- [ ] 实现 Entity/Repository 层 — 依赖表结构
+- [ ] 实现 Service/UseCase 层 — 依赖 Repository
+- [ ] 实现 Controller/Handler 层 — 依赖 Service
+- [ ] 实现单元测试（覆盖核心逻辑和边界条件）
+- [ ] 自测通过（接口通、数据对、边界覆盖）` : `- [ ] 确认后端接口已就绪（依赖后端先完成）
+- [ ] 实现 API 调用封装（请求/错误处理/重试）
+- [ ] 实现状态管理（全局状态 + 本地状态）
+- [ ] 实现页面组件和路由配置
+- [ ] 实现表单校验和字段映射
+- [ ] 实现 UI 测试（关键流程覆盖）
+- [ ] 自测通过（页面渲染、交互响应、API 连通）`}
+
+### 第四阶段：验收交付
+- [ ] 更新 TASK.md 进度
+- [ ] 提交代码并关联本任务
+- [ ] 通知相关端联调
+
+## ${isBk ? '接口清单' : '页面清单'}
+${isBk ? apiList : pageList}
+
+## 产出物
+| 产出物 | 状态 | 路径 | 说明 |
+| :--- | :--- | :--- | :--- |
+| TASK.md | ✅ | ./TASK.md | 本文件 |
+| TEST.md | ⏳ | ./TEST.md | ${isBk ? '单元测试 + 接口测试' : 'UI 测试 + 组件测试'} |
+${docSet.hasRisk ? '| RISK.md | ⏳ | ./RISK.md | 风险评估 |\n' : ''}| DEPS.md | ⏳ | ./DEPS.md | 依赖清单 |
+${docSet.hasMonitor ? '| MONITOR.md | ⏳ | ./MONITOR.md | 监控指标 |\n' : ''}| REVIEW.md | ⏳ | ./REVIEW.md | 评审清单 |
+${docSet.hasDeploy ? '| DEPLOY.md | ⏳ | ./DEPLOY.md | 部署检查 |\n' : ''}| ERROR_CODES.md | ⏳ | ./ERROR_CODES.md | 错误码定义 |
+${!isBk && docSet.hasComponentTree ? '| COMPONENT_TREE.md | ⏳ | ./COMPONENT_TREE.md | 组件树 |\n' : ''}${!isBk && docSet.hasFeDesign ? '| ROUTES.md | ⏳ | ./ROUTES.md | 路由设计 |\n| STATE.md | ⏳ | ./STATE.md | 状态管理 |\n| STYLE_GUIDE.md | ⏳ | ./STYLE_GUIDE.md | 样式规范 |\n' : ''}> ⚠️ 代码输出位置：AI 生成的代码写入 CONSTITUTION.md/PROJECT.yaml 中声明的「源码路径」,
+> 不写入迭代目录。子任务目录只存放规格文档。
+
+## 变更履历
+| 时间 | 变更内容 | 变更人 |
+| :--- | :--- | :--- |
+| ${today} | 创建子任务 | CLI |
+`);
+            // 前端设计文档（仅非 backend 端，按任务类型裁剪：bugfix 跳过，refactor 仅组件树）
+            if (!isBk && docSet.hasComponentTree) {
+                const feContent = extractTaskTechContent(specContents, section, platformName);
+                await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'COMPONENT_TREE.md'), generateComponentTree(section, platformName, feContent));
+                if (docSet.hasFeDesign) {
+                    await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'ROUTES.md'), generateRoutesDoc(section, platformName, feContent));
+                    await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'STATE.md'), generateStateDoc(section, platformName, feContent));
+                    await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'STYLE_GUIDE.md'), generateStyleGuide(section, platformName, feContent));
+                }
+            }
+            // v8.3.60+: 自动生成 VERIFY_SPEC.yaml（从源码路由扫描，所有前端端均生成）
+            if (!isBk) {
+                try {
+                    const projectConfig = await (0, unified_config_1.loadProjectConfig)();
+                    const platformConfig = projectConfig.platforms.find(p => p.name === platformName);
+                    const codePath = platformConfig?.code_path
+                        ? ((0, path_1.isAbsolute)(platformConfig.code_path)
+                            ? platformConfig.code_path
+                            : (0, path_1.join)(process.cwd(), platformConfig.code_path))
+                        : null;
+                    if (codePath && await (0, fs_extra_1.pathExists)(codePath)) {
+                        const routeResult = await (0, ui_verify_1.scanRoutes)(codePath);
+                        if (routeResult.routes.length > 0) {
+                            const baseUrl = 'http://localhost:3000'; // 默认值，开发时调整
+                            const spec = (0, ui_verify_1.generateSpecFromRoutes)(routeResult.routes, {
+                                baseUrl,
+                                platform: platformName,
+                                name: `${section.name} - ${platformName} UI 验证`,
+                            });
+                            await (0, ui_verify_1.writeVerifySpec)(spec, (0, path_1.join)(subtaskDir, 'VERIFY_SPEC.yaml'));
+                            logger_1.logger.info(`   📄 VERIFY_SPEC.yaml 已自动生成（${routeResult.routes.length} 个场景）`);
+                        }
+                    }
+                }
+                catch {
+                    // 静默失败：源码不可用或扫描失败时不阻断 split 流程
+                }
+            }
+            // 执行产出文档（按任务类型裁剪：bugfix 无 RISK/MONITOR/DEPLOY，refactor 无 MONITOR/DEPLOY）
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'TEST.md'), generateTestOutline(section, testMaterial));
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'REVIEW.md'), generateReviewChecklist(section));
+            if (docSet.hasDeploy)
+                await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'DEPLOY.md'), generateDeployChecklist(section));
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'ERROR_CODES.md'), generateErrorCodes(section));
+            if (docSet.hasRisk)
+                await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'RISK.md'), generateRiskTemplate(section, riskMaterial));
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'DEPS.md'), generateDepsTemplate(section, depsMaterial));
+            if (docSet.hasMonitor)
+                await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'MONITOR.md'), generateMonitorTemplate(section, monitorMaterial));
+            // v8.0.0+: 预创建 REQ.md 和 TECH.md 骨架文件
+            // AI 用 Write 覆盖这些文件，不再自行创建路径（消除路径错误）
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'REQ.md'), `${spec_skeleton_1.SKELETON_MARKER}\n# ${section.name} — ${platformLabel}\n\n> 本文件由 CLI 预创建，请用 Write 工具覆盖为专业需求规格。\n\n## 功能描述\n<!-- AI-FILL: 本端的需求描述 -->\n\n## 验收标准\n<!-- AI-FILL: Given/When/Then 格式 -->\n\n## 业务规则\n<!-- AI-FILL -->\n\n## 边界条件\n<!-- AI-FILL -->\n\n## 异常场景\n<!-- AI-FILL -->\n`);
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'TECH.md'), `${spec_skeleton_1.SKELETON_MARKER}\n# ${section.name} — ${platformLabel} 技术方案\n\n> 本文件由 CLI 预创建，请用 Write 工具覆盖为专业技术方案。\n\n## 接口定义\n<!-- AI-FILL: 请求/响应结构体 -->\n\n## 数据模型\n<!-- AI-FILL: 字段/类型/约束 -->\n\n## 核心逻辑\n<!-- AI-FILL -->\n\n## 依赖说明\n<!-- AI-FILL -->\n`);
+            if (docSet.hasAdr) {
+                const adr = generateAdr(section);
+                if (adr) {
+                    await (0, fs_extra_1.writeFile)((0, path_1.join)(subtaskDir, 'ADR.md'), adr);
+                }
+            }
+        };
+        // ── 所有端平铺：{端名}/{子任务}/ （v6.49.2+ 统一架构）──
+        // 不再区分前后端，所有端平铺在任务目录下
+        // 子任务目录名使用 generateSubtaskId 生成的全局唯一 ID：Task-{num}-{platform}
+        for (const platform of taskPlatforms) {
+            const platformDir = (0, path_1.join)(taskDir, platform);
+            const subtaskId = subtaskIdMap.get(platform);
+            // 子任务目录名 = subtaskId（如 Task-001-booking-service）
+            const subtaskDir = (0, path_1.join)(platformDir, subtaskId);
+            const subtaskHours = complexity.estimatedHours || 8;
+            // 判断是否后端（用于生成不同的文档内容）
+            const isBk = platform === 'backend' || platform.startsWith('后台') || /-(service|api|server|backend)$/i.test(platform);
+            await createSubtask(subtaskDir, subtaskId, platform, isBk ? '后端' : platform, isBk, subtaskHours);
+        }
+    }
+    // 确保至少有 backend 子任务（AI 未输出 backend 时自动补充，仅非 research）
+    // v6.48.0+：从 CONSTITUTION.md 端列表查找后端端名，不再硬编码 'backend'
+    const hasAnyBackend = taskPlatforms.some((p) => p === 'backend' || p.startsWith('后台') || /-(service|api|server|backend)$/i.test(p));
+    if (!isResearch && !hasAnyBackend) {
+        // 从端列表查找第一个后端端名作为 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 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');
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'owner'), owner);
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'created-at'), today);
+        // v8.3.5+: 子任务工时
+        const autoHours = complexity.estimatedHours || 8;
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'estimated-hours'), String(autoHours));
+        // 功能单元标识（v6.49.2+）
+        const featureName = section.functionalUnit || section.name || '未分类';
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'feature'), featureName);
+        // v8.3.4+: git-config 自动填充
+        // v8.3.118+: 传入全局 branch_types
+        const gitConfig = (0, git_integration_1.loadGitConfig)(iterationName);
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, '.meta', 'git-config'), buildGitConfigContent(gitConfig, '后端', section.type, branchTypes));
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'TASK.md'), `# ${section.name} — ${fallbackBackend}（自动补充）
+
+## 子任务信息
+- **子任务 ID**: \`${taskId}-${fallbackBackend}-auto\`
+- **所属模块**: \`${taskId}\`
+- **功能单元**: ${featureName}
+- **端**: ${fallbackBackend}
+- **负责人**: ${owner}
+- **状态**: 待开发
+
+## 共享规格引用
+- REQ.md → ../../../00-specs/REQ.md
+- TECH.md → ../../../00-specs/TECH.md
+`);
+        // 自动补充的后端也需要执行产出文档（按任务类型裁剪）
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'TEST.md'), generateTestOutline(section, testMaterial));
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'REVIEW.md'), generateReviewChecklist(section));
+        if (docSet.hasDeploy)
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'DEPLOY.md'), generateDeployChecklist(section));
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'ERROR_CODES.md'), generateErrorCodes(section));
+        if (docSet.hasRisk)
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'RISK.md'), generateRiskTemplate(section, riskMaterial));
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'DEPS.md'), generateDepsTemplate(section, depsMaterial));
+        if (docSet.hasMonitor)
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(autoSubtaskDir, 'MONITOR.md'), generateMonitorTemplate(section, monitorMaterial));
+        taskPlatforms.push(fallbackBackend);
+        subtaskIdMap.set(fallbackBackend, `${taskId}-${fallbackBackend}-auto`);
+    }
+    // ─ 5. 任务上下文 CONTEXT.md ─
+    const sourceFile = section._sourceFile || '';
+    const topic = section._topic || slugify(section.name);
+    // 推导 010-requirements 源路径
+    const reqSourcePath = sourceFile
+        ? `010-requirements/${sourceFile}`
+        : `010-requirements/${taskType === 'feature' ? 'features' : taskType === 'bugfix' ? 'bugs' : taskType === 'refactor' ? 'refactors' : 'research'}/${topic}.md`;
+    // 推导 020-specs 分析文档路径
+    const specSourcePath = sourceFile
+        ? `020-specs/${sourceFile}`
+        : `020-specs/${taskType === 'feature' ? 'features' : taskType === 'bugfix' ? 'bugs' : taskType === 'refactor' ? 'refactors' : 'research'}/${topic}.md`;
+    // 任务类型中文标签
+    const typeLabels = { feature: '功能开发', bugfix: '缺陷修复', refactor: '重构优化', research: '技术调研' };
+    const typeLabel = typeLabels[taskType] || taskType;
+    // 收集同迭代的其它任务（用于关联关系）
+    const relatedTasks = allSections
+        ? allSections
+            .filter((s) => s !== section)
+            .slice(0, 5)
+            .map((s, idx) => {
+            const sId = s._taskId || `Task-${String(allSections.indexOf(s) + 1).padStart(3, '0')}`;
+            const sType = s._taskType || 'feature';
+            return `- \`${sId}\` (${s.name}) — ${typeLabels[sType] || sType}`;
+        })
+        : [];
+    // 提取原始描述摘要（从 REQ.md 内容截取前 500 字）
+    const reqMdPath = (0, path_1.join)(taskDir, '00-specs', 'REQ.md');
+    let originalDesc = '';
+    if (await (0, fs_extra_1.pathExists)(reqMdPath)) {
+        const reqContent = await (0, fs_extra_1.readFile)(reqMdPath, 'utf-8');
+        // 跳过标题行，取正文前 500 字
+        const body = reqContent.replace(/^#[^\n]*\n/, '').trim();
+        originalDesc = body.length > 500 ? body.slice(0, 500) + '...' : body;
+    }
+    // v6.69.3+: CONTEXT.md 写入 _shared/（符合规范），同时保留 00-specs/ 副本供兼容
+    const contextContent = `# 任务上下文
+
+## 来源追溯
+
+| 属性 | 值 |
+|:---|:---|
+| 任务类型 | ${typeLabel}（\`${taskType}\`） |
+| 需求文档 | \`${reqSourcePath}\` |
+| 分析文档 | \`${specSourcePath}\` |
+| 功能单元 | ${section.functionalUnit || section.name} |
+| 拆分原因 | ${section._reason || '—'} |
+
+## 原始描述
+
+${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);
+    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`);
+}
+async function updateProjectGraph(iterationDir, sections) {
+    const graphPath = (0, path_1.join)(iterationDir, '000-overview', 'PROJECT_GRAPH.md');
+    let content = '';
+    if (await (0, fs_extra_1.pathExists)(graphPath)) {
+        content = await (0, fs_extra_1.readFile)(graphPath, 'utf-8');
+    }
+    for (let i = 0; i < sections.length; i++) {
+        const taskId = sections[i]._taskId || `Task-${String(i + 1).padStart(3, '0')}`;
+        let taskName = sections[i].name;
+        while (/端端/.test(taskName))
+            taskName = taskName.replace('端端', '端');
+        if (!content.includes(taskId)) {
+            const taskEntry = `| ${taskId} | ${taskName} | ${sections[i]._taskType || 'feature'} | 0% | 🔲 待开发 | |\n`;
+            content = content.replace('| 任务编号 | 任务名称 | 类型 | 进度 | 状态 | 负责人 |\n| :--- | :--- | :--- | :--- | :--- | :--- |\n', `| 任务编号 | 任务名称 | 类型 | 进度 | 状态 | 负责人 |\n| :--- | :--- | :--- | :--- | :--- | :--- |\n${taskEntry}`);
+        }
+    }
+    await (0, fs_extra_1.writeFile)(graphPath, content);
+}
+/**
+ * 根据需求内容自动生成测试用例框架
+ */
+function generateTestOutline(section, material) {
+    // v8.3.239+: 阈值统一 200 字符，低质量提取片段不再替换内容感知模板
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 测试用例\n\n> 来源: analyze → TEST.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    const name = section.name;
+    const content = section.content || '';
+    const isBackend = section.platform?.startsWith('后台') || false;
+    const hasApi = content.includes('/api/') || content.includes('接口');
+    const hasDb = content.includes('数据表') || content.includes('数据库') || content.includes('表');
+    // v6.79.0+: 从 content 提取 API 表格生成针对性测试用例
+    const apiRows = extractApiRowsFromContent(content);
+    let outline = `# ${name} — 测试用例\n\n`;
+    outline += `> 自动生成于 split，请在编码后补充具体用例\n\n`;
+    outline += `## 1. 单元测试\n\n`;
+    if (isBackend && hasApi && apiRows.length > 0) {
+        outline += `| 用例 | 接口 | 输入 | 预期 | 状态 |\n`;
+        outline += `| :--- | :--- | :--- | :--- | :--- |\n`;
+        for (const row of apiRows.slice(0, 6)) {
+            outline += `| ${row.method} ${row.path} | ${row.path} | 正常参数 | 200 | ⬜ |\n`;
+            outline += `| ${row.method} ${row.path} 异常 | ${row.path} | 非法参数 | 400/500 | ⬜ |\n`;
+        }
+    }
+    else if (isBackend && hasApi) {
+        outline += `| 用例 | 接口 | 输入 | 预期 | 状态 |\n`;
+        outline += `| :--- | :--- | :--- | :--- | :--- |\n`;
+        outline += `| 正常请求 | | | 200 | ⬜ |\n`;
+        outline += `| 参数校验 | | | 400 | ⬜ |\n`;
+        outline += `| 未授权 | | | 401 | ⬜ |\n`;
+    }
+    else {
+        outline += `| 用例 | 场景 | 输入 | 预期 | 状态 |\n`;
+        outline += `| :--- | :--- | :--- | :--- | :--- |\n`;
+        outline += `| 正常渲染 | 默认 | | | ⬜ |\n`;
+        outline += `| 空数据 | 无数据 | | | ⬜ |\n`;
+    }
+    if (hasDb) {
+        outline += `\n## 2. 数据库测试\n\n`;
+        outline += `| 用例 | 表 | 操作 | 预期 | 状态 |\n`;
+        outline += `| :--- | :--- | :--- | :--- | :--- |\n`;
+        outline += `| 事务回滚 | | INSERT/UPDATE | 异常时回滚 | ⬜ |\n`;
+        outline += `| 唯一约束 | | INSERT 重复 | 约束冲突 | ⬜ |\n`;
+    }
+    outline += `\n## 3. 集成测试 / E2E\n\n`;
+    outline += `| 用例 | 流程 | 预期 | 状态 |\n`;
+    outline += `| :--- | :--- | :--- | :--- |\n`;
+    outline += `| 正常流程 | 从头到尾走通 | 成功 | ⬜ |\n`;
+    outline += `| 异常流程 | 中断/超时 | 优雅降级 | ⬜ |\n`;
+    outline += `| 并发 | 多用户同时操作 | 无数据错乱 | ⬜ |\n`;
+    outline += `\n## 4. 性能 / 安全\n\n`;
+    outline += `| 用例 | 指标 | 阈值 | 状态 |\n`;
+    outline += `| :--- | :--- | :--- | :--- |\n`;
+    outline += `| 响应时间 | P99 | < 500ms | ⬜ |\n`;
+    outline += `| 并发容量 | QPS | 满足预期 | ⬜ |\n`;
+    outline += `\n> ⬜ 待编写 | ✅ 通过 | ❌ 失败 | ➖ 不适用\n`;
+    return outline;
+}
+/** v6.79.0+: 从任务内容中提取 API 表格行 */
+function extractApiRowsFromContent(content) {
+    const rows = [];
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+        const m = line.match(/\|\s*(GET|POST|PUT|DELETE|PATCH)\s*\|\s*([^|]+)\|/i);
+        if (m) {
+            rows.push({ method: m[1].toUpperCase(), path: m[2].trim(), desc: '' });
+        }
+    }
+    return rows;
+}
+/**
+ * 根据需求内容自动生成代码审查清单
+ */
+function generateReviewChecklist(section, material) {
+    // v8.3.239+: 阈值统一 200 字符（分析层暂无 REVIEW 提取源，material 恒空，走内容感知模板）
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — Code Review Checklist\n\n> 来源: analyze → REVIEW.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    const name = section.name;
+    const content = section.content || '';
+    const hasApi = content.includes('/api/') || content.includes('接口');
+    const hasDb = content.includes('数据库') || content.includes('表');
+    const hasBatch = content.includes('批量') || content.includes('导出');
+    const hasAuth = content.includes('权限') || content.includes('角色') || content.includes('认证');
+    const isBackend = section.platform?.startsWith('后台') || false;
+    let checklist = `# ${name} — Code Review Checklist\n\n`;
+    checklist += `> 自动生成于 split，请在提交 PR 前逐项确认\n\n`;
+    checklist += `## 功能正确性\n\n`;
+    checklist += `- [ ] 需求覆盖完整，无遗漏\n`;
+    checklist += `- [ ] 边界条件处理（空值、极值、特殊字符）\n`;
+    checklist += `- [ ] 错误码统一\n\n`;
+    checklist += `## 代码质量\n\n`;
+    checklist += `- [ ] 零 ` + '`any`' + ` 类型\n`;
+    checklist += `- [ ] 无 console.log 残留\n`;
+    checklist += `- [ ] 命名清晰、见名知义\n`;
+    checklist += `- [ ] 无重复代码（>3 次提取为函数）\n\n`;
+    if (isBackend) {
+        checklist += `## 后端专项\n\n`;
+        checklist += `- [ ] 接口幂等性\n`;
+        checklist += `- [ ] 参数校验（@Valid / DTO）\n`;
+        checklist += `- [ ] 防 SQL 注入\n`;
+        checklist += `- [ ] 日志脱敏（密码/手机号不打日志）\n`;
+        if (hasDb) {
+            checklist += `- [ ] 数据库事务边界正确\n`;
+            checklist += `- [ ] 索引是否匹配查询条件\n`;
+        }
+        if (hasBatch) {
+            checklist += `- [ ] 批量操作有上限限制\n`;
+            checklist += `- [ ] 大数据量分页处理\n`;
+        }
+        if (hasAuth) {
+            checklist += `- [ ] 权限校验在每个接口入口（不是中间件漏掉）\n`;
+        }
+        checklist += `\n`;
+    }
+    else {
+        checklist += `## 前端专项\n\n`;
+        checklist += `- [ ] 组件拆分合理（>200 行考虑拆分）\n`;
+        checklist += `- [ ] 无 XSS 漏洞（v-html 审查）\n`;
+        checklist += `- [ ] 响应式适配\n`;
+        checklist += `- [ ] 加载态 / 空态 / 错误态 / 边界态（四态齐全）\n\n`;
+    }
+    checklist += `## 测试\n\n`;
+    checklist += `- [ ] 核心路径有单元测试\n`;
+    checklist += `- [ ] 参照 \`TEST.md\` 逐项验证\n`;
+    checklist += `- [ ] \`speccore validate --task=${name}\` 通过\n\n`;
+    checklist += `## 自查确认\n\n`;
+    checklist += `- [ ] 已在本地完整跑通\n`;
+    checklist += `- [ ] 相关的 \`REQ.md\` 已更新（如有变化）\n`;
+    checklist += `- [ ] PR 描述写清楚了「做了什么 + 怎么测」\n`;
+    return checklist;
+}
+/**
+ * 严格模式：预览拆分方案，逐 section 确认
+ */
+async function strictSplitPreview(sections, platforms, iterationDir) {
+    const ask = (q) => {
+        process.stdout.write(q);
+        return new Promise((resolve) => {
+            process.stdin.resume();
+            process.stdin.once('data', (data) => {
+                process.stdin.pause();
+                resolve(data.toString().split(/\r?\n/)[0].trim());
+            });
+        });
+    };
+    logger_1.logger.info('\n╔══════════════════════════════════════════╗');
+    logger_1.logger.info('║  🔍 Strict Split — 预览拆分方案          ║');
+    logger_1.logger.info('╚══════════════════════════════════════════╝\n');
+    logger_1.logger.info(`检测到 ${sections.length} 个章节，${platforms.length} 个端: ${platforms.join(', ')}\n`);
+    const approved = [];
+    for (let i = 0; i < sections.length; i++) {
+        const s = sections[i];
+        const taskId = s._taskId || `Task-${String(i + 1).padStart(3, '0')}`;
+        // Determine target directory
+        const target = s.platform || platforms.join(' + ');
+        logger_1.logger.info(`── ${taskId}: ${s.name} ──`);
+        logger_1.logger.info(`   端: ${target}`);
+        logger_1.logger.info(`   内容: ${(s.content || '').slice(0, 60).replace(/\n/g, ' ')}...`);
+        const answer = (await ask(`   → 保留？[y]确认 [e]编辑名称 [a]分配 [N]跳过 [q]取消: `)).toLowerCase();
+        if (answer === 'q') {
+            logger_1.logger.info('  ❌ 取消全部\n');
+            approved.length = 0;
+            break;
+        }
+        if (answer === 'a') {
+            const owner = await ask(`   → 分配给谁？（如需要多端，用逗号分隔: 张三(后台),李四(Web)）: `);
+            if (owner) {
+                // Store owner info for later use
+                s._owner = owner;
+                logger_1.logger.info(`  👤 负责人: ${owner}`);
+            }
+            approved.push(s);
+            logger_1.logger.info(`  ✅ 保留`);
+        }
+        else if (answer === 'e') {
+            const newName = await ask(`   → 新名称: `);
+            if (newName) {
+                s.name = newName;
+                logger_1.logger.info(`  📝 已改名: ${newName}`);
+            }
+            approved.push(s);
+        }
+        else if (answer === 'y' || answer === 'yes') {
+            approved.push(s);
+            logger_1.logger.info(`  ✅ 保留`);
+        }
+        else {
+            logger_1.logger.info(`  ⏭️  跳过`);
+        }
+        logger_1.logger.info('');
+    }
+    if (approved.length === 0)
+        return [];
+    logger_1.logger.info(`\n  将创建 ${approved.length}/${sections.length} 个任务`);
+    const confirm = await ask('  确认创建？[y/N] ');
+    logger_1.logger.info('\n✅ 确认创建...\n');
+    (0, next_steps_1.showNextSteps)('split');
+    return approved;
+}
+/**
+ * 生成任务间影响关系图 + 风险评分
+ */
+async function generateImpactGraph(iterationDir, sections, platforms) {
+    const deps = [];
+    const sectionApis = sections.map((s, i) => {
+        const taskId = s._taskId || `Task-${String(i + 1).padStart(3, '0')}`;
+        const apis = (s.content.match(/\/api\/[a-zA-Z0-9\/-]+/g) || []).map(a => a.trim());
+        return { name: taskId, apis };
+    });
+    for (let i = 0; i < sectionApis.length; i++) {
+        for (let j = 0; j < sectionApis.length; j++) {
+            if (i === j)
+                continue;
+            for (const api of sectionApis[j].apis) {
+                if (sections[i].content.includes(api)) {
+                    deps.push({ from: sectionApis[i].name, fromName: sections[i].name, to: sectionApis[j].name, toName: sections[j].name, reason: api });
+                    break;
+                }
+            }
+        }
+    }
+    const seen = new Set();
+    const uniqueDeps = deps.filter(d => { const k = d.from + d.to; if (seen.has(k))
+        return false; seen.add(k); return true; });
+    let impact = '# IMPACT.md\n\n> auto-generated by split\n\n## Risk Scores\n\n| Task | Risk | Score | Tags | Reasons |\n| :--- | :--- | ---: | :--- | :--- |\n';
+    for (let i = 0; i < sections.length; i++) {
+        const s = sections[i];
+        const taskId = s._taskId || `Task-${String(i + 1).padStart(3, '0')}`;
+        const risk = await (0, risk_scorer_1.scoreRisk)(s.content + s.name, s.name, iterationDir);
+        impact += `| ${taskId}: ${s.name} | ${risk.level} | ${risk.score} | ${risk.tags.join(' ')} | ${risk.reasons.join('; ')} |\n`;
+        const taskType = s._taskType || 'feature';
+        const taskDir = (0, path_1.join)(iterationDir, '030-tasks', taskType, taskId);
+        if (await (0, fs_extra_1.pathExists)(taskDir)) {
+            // 生成风险报告并嵌入 00-specs/TECH.md（去重：只写一次）
+            const taskMdPath = (await (0, fs_extra_1.pathExists)((0, path_1.join)(taskDir, '00-specs', 'TECH.md')))
+                ? (0, path_1.join)(taskDir, '00-specs', 'TECH.md')
+                : (0, path_1.join)(taskDir, '_shared', 'TECH.md');
+            const riskReport = (0, risk_scorer_1.generateRiskReport)(risk);
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.risk'), riskReport);
+            if (await (0, fs_extra_1.pathExists)(taskMdPath)) {
+                let taskMd = await (0, fs_extra_1.readFile)(taskMdPath, 'utf-8');
+                if (!taskMd.includes('## 风险评估')) {
+                    taskMd += '\n\n## 风险评估\n\n' + riskReport.replace('# 风险评估\n\n', '');
+                    await (0, fs_extra_1.writeFile)(taskMdPath, taskMd);
+                }
+            }
+        }
+    }
+    // 语义依赖检测
+    const semanticDeps = detectSemanticDependencies(sections);
+    impact += '\n## Dependencies\n\n';
+    if (uniqueDeps.length > 0 || semanticDeps.size > 0) {
+        impact += '| Consumer | -> | Producer | 类型 |\n| :--- | :---: | :--- | :--- |\n';
+        // API 依赖
+        for (const d of uniqueDeps)
+            impact += `| ${d.from}: ${d.fromName.slice(0, 20)} | → | ${d.to}: ${d.toName.slice(0, 20)} | API: \`${d.reason}\` |\n`;
+        // 语义依赖
+        for (const [from, targets] of semanticDeps) {
+            for (const target of targets) {
+                impact += `| ${from} | → | ${target} | 语义推断 |\n`;
+            }
+        }
+        impact += '\n> Consumer tasks must wait for Producer tasks, or pre-define API contracts.\n';
+    }
+    else {
+        impact += 'No task dependencies detected — all tasks can be developed in parallel.\n';
+    }
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(iterationDir, 'IMPACT.md'), impact);
+    logger_1.logger.info(`\nImpact analysis: ${iterationDir}/IMPACT.md`);
+}
+function generateSchemaTemplate(section, material) {
+    const name = section.name;
+    if (material && material.trim().length > 200) {
+        return `# ${name} — Database Schema\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${name} — Database Schema
+
+> Auto-generated. Fill in DDL before development.
+
+## Tables
+
+| Table | Purpose | Engine | Charset |
+| :--- | :--- | :--- | :--- |
+| | | InnoDB | utf8mb4 |
+
+## DDL
+
+\`\`\`sql
+-- TODO: Write CREATE TABLE statements
+
+\`\`\`
+
+## Indexes
+
+| Table | Index | Columns | Type |
+| :--- | :--- | :--- | :--- |
+| | | | BTREE |
+
+## Migration Plan
+
+- [ ] Dev: Write DDL in local
+- [ ] Review: DBA reviews schema changes
+- [ ] Stage: Run migration on staging
+- [ ] Prod: Run migration during deployment window
+
+## Rollback
+
+\`\`\`sql
+-- TODO: Write rollback DDL
+\`\`\`
+`;
+}
+function generateDeployChecklist(section, material) {
+    // v8.3.239+: 阈值统一 200 字符（分析层暂无 DEPLOY 提取源，material 恒空，走内容感知模板）
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 部署检查清单\n\n> 来源: analyze → DEPLOY.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    const name = section.name;
+    const hasDb = section.content.match(/数据库|数据表|DDL|ALTER/) !== null;
+    return `# ${name} — Deployment Checklist
+
+## Pre-Deploy
+
+- [ ] All tests pass (\`speccore verify\`)
+- [ ] Code review approved (REVIEW.md all checked)
+- [ ] PR merged to main
+- [ ] CI/CD pipeline green
+
+${hasDb ? '- [ ] DB migration script ready and reviewed\n- [ ] DB backup taken before migration\n' : ''}
+## Deploy Steps
+
+1. [ ] Merge to release branch
+2. [ ] Tag version: \`git tag vX.Y.Z\`
+3. [ ] Deploy to staging
+4. [ ] Smoke test on staging
+5. [ ] Deploy to production
+${hasDb ? '6. [ ] Run DB migration\n7. [ ] Verify data integrity\n' : ''}
+## Post-Deploy
+
+- [ ] Monitor error logs (first 30 min)
+- [ ] Monitor performance metrics
+- [ ] Run \`speccore archive --task=${name}\`
+
+## Rollback Plan
+
+- [ ] \`git revert\` the merge commit
+${hasDb ? '- [ ] Run rollback DDL from SCHEMA.md\n' : ''}- [ ] Notify team on rollback
+`;
+}
+async function generateEnvExample(iterationDir, sections) {
+    const envPath = (0, path_1.join)(iterationDir, '.env.example');
+    let env = '# Environment Variables — ' + iterationDir + '\n';
+    env += '# Copy to .env and fill in values\n\n';
+    const needs = new Set();
+    for (const s of sections) {
+        const c = s.content + s.name;
+        if (c.match(/Redis|缓存/))
+            needs.add('REDIS_URL=redis://localhost:6379');
+        if (c.match(/Kafka|MQ|消息队列/))
+            needs.add('KAFKA_BROKERS=localhost:9092');
+        if (c.match(/MySQL|数据库|JDBC|数据表/))
+            needs.add('DB_URL=jdbc:mysql://localhost:3306/db\nDB_USER=root\nDB_PASS=');
+        if (c.match(/OSS|对象存储|S3|文件上传/))
+            needs.add('OSS_ENDPOINT=https://oss.example.com\nOSS_KEY=\nOSS_SECRET=');
+        if (c.match(/支付|微信|支付宝|wechat|alipay/))
+            needs.add('PAYMENT_API_KEY=\nPAYMENT_SECRET=');
+        if (c.match(/短信|SMS|验证码/))
+            needs.add('SMS_API_KEY=\nSMS_SECRET=');
+        if (c.match(/邮件|email|smtp/))
+            needs.add('SMTP_HOST=smtp.example.com\nSMTP_PORT=587\nSMTP_USER=\nSMTP_PASS=');
+        if (c.match(/token|JWT|OAuth|鉴权|登录/))
+            needs.add('JWT_SECRET=\nTOKEN_EXPIRE=3600');
+    }
+    if (needs.size === 0) {
+        needs.add('# No extra environment variables detected.');
+        needs.add('# Add required variables here.');
+    }
+    env += [...needs].join('\n') + '\n';
+    await (0, fs_extra_1.writeFile)(envPath, env);
+    logger_1.logger.info(`Env example: ${iterationDir}/.env.example`);
+}
+async function injectTechFromAnalysis(iterationDir, taskDir, sectionName) {
+    const analysisPathNew = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'ANALYSIS.md');
+    const analysisPathOld = (0, path_1.join)(iterationDir, '020-specs', 'ANALYSIS.md');
+    const analysisPath = await (0, fs_extra_1.pathExists)(analysisPathNew) ? analysisPathNew : analysisPathOld;
+    if (!(await (0, fs_extra_1.pathExists)(analysisPath)))
+        return;
+    const analysis = await (0, fs_extra_1.readFile)(analysisPath, 'utf-8');
+    // Extract relevant tech stack section
+    const techSection = analysis.match(/### 技术选型[\s\S]*?(?=###|$)/);
+    const dbSection = analysis.match(/### 数据库变更[\s\S]*?(?=###|$)/);
+    const depSection = analysis.match(/### 接口依赖[\s\S]*?(?=###|$)/);
+    if (!techSection && !dbSection && !depSection)
+        return;
+    const techPath = (await (0, fs_extra_1.pathExists)((0, path_1.join)(taskDir, '00-specs', 'TECH.md')))
+        ? (0, path_1.join)(taskDir, '00-specs', 'TECH.md')
+        : (0, path_1.join)(taskDir, '_shared', 'TECH.md');
+    let tech = await (0, fs_extra_1.readFile)(techPath, 'utf-8');
+    const note = '\n\n> 以下内容自动从 ANALYSIS.md 注入\n\n';
+    if (techSection && !tech.includes(techSection[0].trim())) {
+        tech += note + techSection[0].trim() + '\n';
+    }
+    if (dbSection && !tech.includes(dbSection[0].trim())) {
+        tech += dbSection[0].trim() + '\n';
+    }
+    if (depSection && !tech.includes(depSection[0].trim())) {
+        tech += depSection[0].trim() + '\n';
+    }
+    await (0, fs_extra_1.writeFile)(techPath, tech);
+}
+function generateApiContract(section) {
+    const lines = (section.content || '').split(/\r?\n/);
+    const apis = [];
+    for (const line of lines) {
+        const match = line.match(/\|\s*(GET|POST|PUT|DELETE|PATCH)\s*\|\s*(\/[^\s|]+)\s*\|\s*(.*)/i);
+        if (match) {
+            apis.push({ method: match[1].toUpperCase(), path: match[2].trim(), desc: (match[3] || '').trim() });
+        }
+    }
+    if (apis.length === 0)
+        return '';
+    // 从 section 内容提取每个 API 的请求/响应字段
+    const fullContent = section.content || '';
+    const apiFieldMap = {};
+    for (const api of apis) {
+        const apiIdx = fullContent.indexOf(api.path);
+        if (apiIdx >= 0) {
+            const after = fullContent.slice(apiIdx, apiIdx + 800);
+            const fields = [];
+            const fieldRegex = /[`']([a-zA-Z]\w{1,25})[`']\s*[（(]?[：:]?\s*(?:类型[：:])?\s*([\u4e00-\u9fa5A-Za-z]+)/g;
+            let fm;
+            while ((fm = fieldRegex.exec(after)) !== null) {
+                if (!['api', 'data', 'code', 'message', 'msg', 'status', 'ok', 'err'].includes(fm[1].toLowerCase())) {
+                    fields.push(`${fm[1]}: ${fm[2]}`);
+                }
+            }
+            if (fields.length > 0)
+                apiFieldMap[api.path] = fields.slice(0, 10);
+        }
+    }
+    let yaml = `# ${section.name} — API Contract
+# Auto-generated from REQ.md
+
+openapi: "3.0.0"
+info:
+  title: "${section.name}"
+  version: "1.0.0"
+
+paths:
+`;
+    for (const api of apis) {
+        const tag = api.path.split('/')[2] || 'default';
+        yaml += `  ${api.path}:
+    ${api.method.toLowerCase()}:
+      tags: [${tag}]
+      summary: "${api.desc}"
+`;
+        // 添加字段定义
+        if (apiFieldMap[api.path]) {
+            yaml += `      fields:
+`;
+            for (const f of apiFieldMap[api.path]) {
+                yaml += `        - "${f}"
+`;
+            }
+        }
+        yaml += `      responses:
+        "200":
+          description: Success
+`;
+        if (api.method === 'POST' || api.method === 'PUT') {
+            yaml += `        "400":
+          description: Bad Request
+`;
+        }
+        if (api.method === 'DELETE') {
+            yaml += `        "404":
+          description: Not Found
+`;
+        }
+    }
+    return yaml;
+}
+function generateErrorCodes(section) {
+    let md = `# ${section.name} — Error Codes\n\n> Auto-generated\n\n`;
+    md += `| Code | HTTP | Message | Description |\n`;
+    md += `| :--- | :--- | :--- | :--- |\n`;
+    const content = section.content || '';
+    const module = section.name.replace(/[^\w]/g, '_').toUpperCase();
+    md += `| ${module}_001 | 400 | 参数校验失败 | 请求参数不符合规范 |\n`;
+    md += `| ${module}_002 | 404 | 资源不存在 | 请求的资源未找到 |\n`;
+    md += `| ${module}_003 | 500 | 服务器内部错误 | 未预期的服务异常 |\n`;
+    if (content.includes('权限') || content.includes('RBAC')) {
+        md += `| ${module}_004 | 403 | 无操作权限 | 当前用户权限不足 |\n`;
+    }
+    if (content.includes('创建') || content.includes('POST')) {
+        md += `| ${module}_005 | 409 | 资源冲突 | 重复创建或状态冲突 |\n`;
+    }
+    return md;
+}
+function generateAdr(section) {
+    const content = section.content || '';
+    // Only generate ADR if tech decisions are mentioned
+    const hasTech = content.match(/Spring|Vue|React|MySQL|Redis|Kafka|微服务|单体|REST|gRPC/);
+    if (!hasTech)
+        return '';
+    const now = new Date().toISOString().split('T')[0];
+    let adr = `# ADR: ${section.name}\n\n`;
+    adr += `- **日期**: ${now}\n`;
+    adr += `- **状态**: 提议中\n\n`;
+    adr += `## 决策\n\n`;
+    const techStack = content.match(/(Spring|Vue|React|MySQL|Redis|Kafka|微服务|单体|REST|gRPC)[^\n]*/g);
+    if (techStack) {
+        adr += `基于任务需求，技术选型如下:\n\n`;
+        for (const t of [...new Set(techStack)]) {
+            adr += `- ${t.trim()}\n`;
+        }
+    }
+    adr += `\n## 备选方案\n\n- _待补充_\n`;
+    adr += `\n## 后果\n\n- _待补充_\n`;
+    return adr;
+}
+// ── AC 自动生成 ──
+function generateAcceptanceCriteria(section) {
+    const lines = section.content.split(/\r?\n/);
+    let acs = '';
+    let acNum = 1;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('|') && (trimmed.includes('GET') || trimmed.includes('POST') || trimmed.includes('PUT') || trimmed.includes('DELETE') || trimmed.includes('PATCH'))) {
+            const parts = trimmed.split('|').map(p => p.trim()).filter(Boolean);
+            const method = parts[0] || '';
+            const path = parts[1] || '';
+            const desc = parts[2] || path;
+            acs += `- [ ] AC-${acNum++}: \`${method} ${path}\` — ${desc}\n`;
+        }
+        if (trimmed.startsWith('-') && (trimmed.includes('规则') || trimmed.includes('校验') || trimmed.includes('必须'))) {
+            acs += `- [ ] AC-${acNum++}: ${trimmed.replace(/^- /, '')}\n`;
+        }
+    }
+    if (acNum === 1) {
+        acs = `- [ ] AC-1: 功能实现与需求描述一致\n- [ ] AC-2: 异常输入有合理的错误处理\n- [ ] AC-3: 核心逻辑有单元测试覆盖\n`;
+        acNum = 4;
+    }
+    acs += `- [ ] AC-${acNum++}: 代码审查通过（REVIEW.md 全部已确认）\n`;
+    acs += `- [ ] AC-${acNum++}: 部署清单完成（DEPLOY.md 全部已确认）\n`;
+    return acs;
+}
+// 风险评估
+function generateRiskTemplate(section, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 风险评估\n\n> 来源: analyze → RISK.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${section.name} — 风险评估\n\n> split | ${new Date().toISOString().split('T')[0]}\n\n## 风险矩阵\n\n| 风险 | 可能 | 影响 | 缓解 |\n| :--- | :--- | :--- | :--- |\n| 兼容性 | 中 | 高 | 版本号+测试 |\n| 性能 | 低 | 中 | 压测+索引 |\n| 依赖故障 | 低 | 高 | 降级方案 |\n\n## 回滚\n\n1. 触发: 线上错误率 > 1%\n2. 步骤: git revert → 重部署\n3. 验证: 冒烟测试 + 监控\n`;
+}
+// 依赖清单
+function generateDepsTemplate(section, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 依赖清单\n\n> 来源: analyze → DEPS.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${section.name} — 依赖清单\n\n## 上游依赖\n\n| 服务 | 版本 | 用途 | SLA |\n| :--- | :--- | :--- | :--- |\n| _待补充_ | — | — | — |\n\n## 下游影响\n\n| 服务 | 影响 | 通知 |\n| :--- | :--- | :--- |\n| _待补充_ | — | — |\n`;
+}
+// 监控指标
+function generateMonitorTemplate(section, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 监控\n\n> 来源: analyze → MONITOR.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${section.name} — 监控\n\n## 关键指标\n\n| 指标 | 阈值 | 级别 |\n| :--- | :--- | :--- |\n| 成功率 | <99.9% | P1 |\n| P99延迟 | >1000ms | P2 |\n| 错误率 | >0.1% | P0 |\n\n## 关键日志\n\n- 请求入口 (traceId)\n- 业务异常 (上下文)\n- 外部调用 (耗时)\n`;
+}
+// ═══════════════════════════════════════════════
+// 从 analyze 产出中提取任务相关内容
+// ═══════════════════════════════════════════════
+/** 加载迭代级 020-specs/ 文档内容（包括 global/ 全局文档 + 根目录回退 + 各端子目录文档） */
+async function loadSpecContents(iterationDir) {
+    const specs = {};
+    const specDir = (0, path_1.join)(iterationDir, '020-specs');
+    if (!(await (0, fs_extra_1.pathExists)(specDir)))
+        return specs;
+    // v8.3.21+: 读取全局文档（overview/ 下）
+    const overviewDir = (0, path_1.join)(specDir, spec_paths_1.GLOBAL_SPECS_DIR);
+    if (await (0, fs_extra_1.pathExists)(overviewDir)) {
+        const overviewFiles = await (0, fs_extra_1.readdir)(overviewDir, { withFileTypes: true });
+        for (const f of overviewFiles) {
+            if (!f.name.endsWith('.md'))
+                continue;
+            const fp = (0, path_1.join)(overviewDir, f.name);
+            const content = await (0, fs_extra_1.readFile)(fp, 'utf-8');
+            if (content.trim().length > 50 && !content.trim().match(/^#+\s*待填充|^<!--\s*AI-FILL/m)) {
+                specs[f.name] = content;
+            }
+        }
+    }
+    // v8.3.21+: 读取各功能模块下的文档
+    const features = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+    for (const feature of features) {
+        const featureDir = (0, path_1.join)(specDir, feature);
+        if (!await (0, fs_extra_1.pathExists)(featureDir))
+            continue;
+        const entries = await (0, fs_extra_1.readdir)(featureDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            const subDir = (0, path_1.join)(featureDir, entry.name);
+            const subFiles = await (0, fs_extra_1.readdir)(subDir, { withFileTypes: true });
+            for (const sf of subFiles) {
+                if (!sf.name.endsWith('.md'))
+                    continue;
+                const fp = (0, path_1.join)(subDir, sf.name);
+                const content = await (0, fs_extra_1.readFile)(fp, 'utf-8');
+                if (content.trim().length > 50 && !content.trim().match(/^#+\s*待填充|^<!--\s*AI-FILL/m)) {
+                    specs[`${feature}/${entry.name}/${sf.name}`] = content;
+                }
+            }
+        }
+    }
+    return specs;
+}
+// ═══════════════════════════════════════════════
+// v8.3.125+: 三层匹配 — 精确 + 关键词交集 + 文档标题
+// ═══════════════════════════════════════════════
+// v8.3.125+: extractNormalizedKeywords 和 expandSynonyms 已提取到 ../../utils/synonyms
+/** 第二层：关键词集合交集得分 */
+function scoreKeywordOverlap(taskName, docPath) {
+    const taskKws = (0, synonyms_1.expandSynonyms)((0, synonyms_1.extractNormalizedKeywords)(taskName));
+    const pathKws = (0, synonyms_1.expandSynonyms)((0, synonyms_1.extractNormalizedKeywords)(docPath));
+    let score = 0;
+    for (const tkw of taskKws) {
+        for (const pkw of pathKws) {
+            if (tkw === pkw || tkw.includes(pkw) || pkw.includes(tkw)) {
+                score += 10;
+                break;
+            }
+        }
+    }
+    return score;
+}
+/** 第三层：文档标题匹配得分 */
+function scoreHeadingMatch(taskName, docContent) {
+    const taskKws = (0, synonyms_1.expandSynonyms)((0, synonyms_1.extractNormalizedKeywords)(taskName));
+    const headingRegex = /^(#{1,3})\s+(.+)$/gm;
+    let score = 0;
+    let match;
+    while ((match = headingRegex.exec(docContent)) !== null) {
+        const headingKws = (0, synonyms_1.expandSynonyms)((0, synonyms_1.extractNormalizedKeywords)(match[2]));
+        for (const tkw of taskKws) {
+            for (const hkw of headingKws) {
+                if (tkw === hkw || tkw.includes(hkw) || hkw.includes(tkw)) {
+                    score += 8;
+                    break;
+                }
+            }
+        }
+    }
+    return score;
+}
+/** 三层匹配：找到与任务最匹配的文档 key
+ * @returns 最佳匹配的 {key, score}，无匹配返回 null
+ */
+function findBestSpecMatch(specContents, taskName, platform, docType) {
+    const entries = Object.entries(specContents);
+    if (entries.length === 0 || !taskName)
+        return null;
+    const candidates = [];
+    for (const [key, content] of entries) {
+        // 如果指定了 docType，过滤不匹配的文档类型
+        if (docType && !key.endsWith(docType))
+            continue;
+        let score = 0;
+        // 第一层：精确匹配（字符串包含，最高权重）
+        const normalizedTask = taskName.toLowerCase().replace(/\s+/g, '');
+        const normalizedKey = key.toLowerCase().replace(/[\/\-_\.]/g, '');
+        if (normalizedKey.includes(normalizedTask) || normalizedTask.includes(normalizedKey)) {
+            score += 100;
+        }
+        // 第二层：关键词集合交集
+        score += scoreKeywordOverlap(taskName, key);
+        // 第三层：文档标题匹配
+        score += scoreHeadingMatch(taskName, content);
+        // 平台匹配加分（如果指定了 platform）
+        if (platform) {
+            const pLower = platform.toLowerCase();
+            if (key.toLowerCase().includes(`/${pLower}/`) || key.toLowerCase().startsWith(`${pLower}/`)) {
+                score += 20;
+            }
+        }
+        if (score > 0)
+            candidates.push({ key, score });
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => b.score - a.score);
+    return candidates[0];
+}
+/** 从完整文档中提取与任务名相关的段落 */
+function extractRelevantSection(fullContent, taskName, sectionHint) {
+    if (!fullContent || !taskName)
+        return '';
+    const lines = fullContent.split(/\r?\n/);
+    const nameKeywords = new Set();
+    for (const m of taskName.matchAll(/[a-zA-Z]+/g)) {
+        if (m[0].length > 1)
+            nameKeywords.add(m[0].toLowerCase());
+    }
+    for (const m of taskName.matchAll(/[\u4e00-\u9fff]+/g)) {
+        if (m[0].length >= 2)
+            nameKeywords.add(m[0]);
+    }
+    if (sectionHint) {
+        for (const m of sectionHint.matchAll(/[a-zA-Z]+/g)) {
+            if (m[0].length > 1)
+                nameKeywords.add(m[0].toLowerCase());
+        }
+        for (const m of sectionHint.matchAll(/[\u4e00-\u9fff]+/g)) {
+            if (m[0].length >= 2)
+                nameKeywords.add(m[0]);
+        }
+    }
+    if (nameKeywords.size === 0)
+        return '';
+    const kwArray = [...nameKeywords];
+    // 按 Markdown 标题拆分，查找包含关键词的完整段落
+    const sections = [];
+    let cur = { heading: '', level: 0, content: [], headingLine: '' };
+    for (const line of lines) {
+        const hm = line.match(/^(#{1,4})\s+(.+)/);
+        if (hm) {
+            if (cur.heading || cur.content.length > 0)
+                sections.push({ heading: cur.heading, level: cur.level, content: cur.content.join('\n'), headingLine: cur.headingLine });
+            cur = { heading: hm[2].trim(), level: hm[1].length, content: [], headingLine: line };
+        }
+        else {
+            cur.content.push(line);
+        }
+    }
+    if (cur.heading || cur.content.length > 0)
+        sections.push({ heading: cur.heading, level: cur.level, content: cur.content.join('\n'), headingLine: cur.headingLine });
+    // 匹配：标题或内容包含关键词
+    const matched = [];
+    for (const sec of sections) {
+        const text = (sec.heading + ' ' + sec.content).toLowerCase();
+        const hit = kwArray.some(kw => text.includes(kw));
+        if (hit && (sec.heading || sec.content.trim())) {
+            const prefix = '#'.repeat(Math.max(sec.level + 1, 2));
+            matched.push(`${prefix} ${sec.heading}\n${sec.content.trim()}`);
+        }
+    }
+    if (matched.length > 0)
+        return matched.join('\n\n');
+    // 回退：提取包含关键词的连续行
+    const fallback = [];
+    for (const line of lines) {
+        const lower = line.toLowerCase();
+        if (kwArray.some(kw => lower.includes(kw)))
+            fallback.push(line);
+    }
+    return fallback.length > 0 ? fallback.join('\n') : '';
+}
+/** 从 TECH.md 提取前端平台相关内容 */
+function extractFrontendContent(techContent, taskName, platform) {
+    if (!techContent)
+        return '';
+    // 先提取该前端平台相关的顶层段落（如 "H5移动端"、"后台管理端"）
+    const platformLabels = {
+        'h5': ['H5', 'h5', '移动端', 'mobile'],
+        'admin': ['admin', '后台', '管理端', 'Admin'],
+        'web': ['Web', 'web', '前端', '桌面'],
+        'app': ['App', 'app', '客户端'],
+        'miniapp': ['小程序', 'miniapp'],
+    };
+    const platformKws = platformLabels[platform] || [platform];
+    const platformSection = extractRelevantSection(techContent, taskName, platformKws.join(' '));
+    if (platformSection)
+        return platformSection;
+    // 回退：用任务名匹配
+    return extractRelevantSection(techContent, taskName);
+}
+/** 从 specContents 提取任务级 TECH 内容（优先读取对应端的文档）
+ {feature}/{platform}/TECH.md key 为 {feature}/{platform}/TECH.md
+ * v8.3.125+: 使用三层匹配（精确+关键词+标题）替代字符串查找
+ */
+function extractTaskTechContent(specContents, section, platform) {
+    // v8.3.125+: 使用三层匹配找到最佳 TECH.md
+    const bestMatch = findBestSpecMatch(specContents, section.name, platform, 'TECH.md');
+    if (bestMatch && bestMatch.score >= 20) {
+        return extractRelevantSection(specContents[bestMatch.key], section.name);
+    }
+    // 回退：尝试从全局 TECH.md 提取（overview/TECH.md 或根目录 TECH.md）
+    const techMd = specContents['TECH.md'] || specContents['overview/TECH.md'];
+    if (!techMd)
+        return '';
+    if (platform && platform !== 'backend') {
+        return extractFrontendContent(techMd, section.name, platform);
+    }
+    // 后端/共享：提取技术方案、架构、接口设计、数据模型等
+    const techSection = extractRelevantSection(techMd, section.name, '技术方案 架构 接口设计 数据模型 模块设计');
+    return techSection;
+}
+/** v8.3.0+: 从 analyze DEV_GUIDE.md 提取任务级开发指南内容
+ {feature}/{platform}/TECH.md key 为 {feature}/{platform}/DEV_GUIDE.md
+ * v8.3.125+: 使用三层匹配替代字符串查找
+ */
+function extractTaskDevGuideContent(specContents, section, taskPlatforms) {
+    const results = [];
+    // v8.3.125+: 对每个端使用三层匹配找最佳 DEV_GUIDE.md
+    for (const platform of taskPlatforms) {
+        const bestMatch = findBestSpecMatch(specContents, section.name, platform, 'DEV_GUIDE.md');
+        if (bestMatch && bestMatch.score >= 20) {
+            const extracted = extractRelevantSection(specContents[bestMatch.key], section.name);
+            if (extracted && extracted.trim().length > 50) {
+                results.push(`## ${platform} 端开发指南\n\n${extracted.trim()}`);
+            }
+        }
+    }
+    // v8.3.171+: 从全局 DEV_GUIDE.md 提取（唯一路径 overview/DEV_GUIDE.md）
+    if (results.length === 0) {
+        const globalDevGuide = specContents['overview/DEV_GUIDE.md'];
+        if (globalDevGuide) {
+            const extracted = extractRelevantSection(globalDevGuide, section.name, '改造范围 实施步骤 接口契约 验证方式 回滚 坑点');
+            if (extracted && extracted.trim().length > 50) {
+                results.push(`## 全局开发指南（本任务相关）\n\n${extracted.trim()}`);
+            }
+        }
+    }
+    return results.join('\n\n');
+}
+// 前端专属：组件树
+function generateComponentTree(section, platform, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 组件树 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${section.name} — 组件树 (${platform})
+
+> split | ${new Date().toISOString().split('T')[0]}
+
+## 页面结构
+<!-- 从 analyze TECH.md 自动提取，若无内容则待补充 -->
+
+## 组件清单
+| 组件 | 路径 | 类型 | 状态 |
+| :--- | :--- | :--- | :--- |
+| _待补充_ | — | — | — |
+
+## 共享组件
+| 组件 | 来源 | 用途 |
+| :--- | :--- | :--- |
+| _待补充_ | — | — |
+`;
+}
+// 前端专属：路由
+function generateRoutesDoc(section, platform, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 路由设计 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${section.name} — 路由设计 (${platform})
+
+> split | ${new Date().toISOString().split('T')[0]}
+
+## 路由表
+| 路径 | 组件 | 权限 | 参数 |
+| :--- | :--- | :--- | :--- |
+| _待AI分析_ | — | — | — |
+
+## 导航结构
+<!-- AI-FILL: 面包屑 / 侧栏 / Tab -->
+`;
+}
+// 前端专属：状态管理
+function generateStateDoc(section, platform, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 状态管理 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    return `# ${section.name} — 状态管理 (${platform})
+
+> split | ${new Date().toISOString().split('T')[0]}
+
+## 全局状态
+| Store | 字段 | 类型 | 持久化 |
+| :--- | :--- | :--- | :--- |
+| _待AI分析_ | — | — | — |
+
+## 组件状态
+| 组件 | 状态 | 来源 |
+| :--- | :--- | :--- |
+| _待补充_ | — | — |
+
+## 数据流
+<!-- AI-FILL: 父→子 props / 子→父 emit / store -->
+`;
+}
+// 前端专属：样式规范
+function generateStyleGuide(section, platform, material) {
+    if (material && material.trim().length > 200) {
+        return `# ${section.name} — 样式规范 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+    }
+    const isH5 = platform.includes('h5') || platform.includes('mobile');
+    const isMiniapp = platform.includes('miniapp') || platform.includes('小程序');
+    const styleCtx = isH5 ? '移动端 H5，注意触控交互和移动适配' :
+        isMiniapp ? '小程序，遵守平台组件规范' : '桌面 Web';
+    return `# ${section.name} — 样式规范 (${platform})
+
+> ${styleCtx}
+
+## 设计 Token
+| Token | 值 | 用途 |
+| :--- | :--- | :--- |
+| --color-primary | #1677FF | 主色 |
+| --spacing-unit | 8px | 间距单位 |
+| --radius | ${isH5 ? '12' : '8'}px | 圆角 |
+
+## 响应式断点
+${isH5 ? '移动端优先，适配 375/414/768' :
+        isMiniapp ? '小程序 rpx 自适应' : '>=1920 / 1440 / 1024 / 768'}
+
+## 动画
+- 页面切换: 300ms ease-in-out
+- 加载态: 骨架屏优先
+`;
+}
+/**
+ * 构建完整的 AI 智能拆分 Prompt（含 SpecCore 理念 + 粒度规则 + 完整上下文）
+ */
+async function buildSplitPrompt(iteration, constitutionContent, reqContent, specContents, standardPlatforms, modulesFilter, platformsFilter, existingTasks, iterationDir, 
+// v8.3.160+: 子 Agent 角色和上下文类型，用于动态调整 Prompt
+subagent, contextType) {
+    // v8.3.160+: 接入 agent-adapter，注入子 Agent 角色定义和上下文裁剪策略
+    const agentCtx = {
+        subagent: subagent || 'task-decomposer',
+        iteration,
+        contextBudget: contextType === 'incremental' ? 5000 : 8000,
+        contextType: contextType || 'full',
+        cwd: iterationDir || process.cwd(),
+    };
+    const agentContextText = await agent_adapter_1.defaultAdapter.prepareContext(agentCtx);
+    let p = `# SpecCore AI 智能拆分\n\n`;
+    p += `> 迭代: ${iteration} | 子 Agent: ${agentCtx.subagent} | 生成: ${new Date().toISOString().split('T')[0]}\n\n`;
+    // 注入子 Agent 上下文（角色定义 + 上下文裁剪策略）
+    p += agentContextText + '\n\n';
+    // v6.76.0+: 拆分范围限制
+    if (modulesFilter?.length || platformsFilter?.length) {
+        p += `## 🎯 拆分范围限制（用户指定）\n\n`;
+        if (modulesFilter?.length) {
+            p += `- **只拆分以下功能模块**: ${modulesFilter.join('、')}\n`;
+            p += `- 如果需求文档中有其他功能模块，**完全忽略**，不要拆分\n`;
+        }
+        if (platformsFilter?.length) {
+            p += `- **只拆分涉及以下端的功能模块**: ${platformsFilter.join('、')}\n`;
+            p += `- 如果某个功能模块不涉及这些端，**跳过不拆**\n`;
+            p += `- 每个任务的 scope 只能包含这些端，不要引入其他端\n`;
+        }
+        p += `\n`;
+    }
+    // v6.76.0+: 增量拆分 — 已有 Task 结构
+    if (existingTasks && existingTasks.size > 0) {
+        p += `## 📂 已有 Task 结构（增量拆分模式）\n\n`;
+        p += `本次拆分为**增量模式**：以下 Task 已存在，如果新拆分的功能单元与已有 Task 匹配，**复用该 Task ID，只追加新端**。\n\n`;
+        for (const [taskName, platforms] of existingTasks.entries()) {
+            p += `- **${taskName}**: 已有端 [${platforms.join(', ')}]\n`;
+        }
+        p += `\n`;
+        p += `### 增量拆分规则\n`;
+        p += `- 如果功能单元与已有 Task 的 functionalUnit 相同 → **复用该 Task ID**，scope 追加新端\n`;
+        p += `- 如果功能单元是全新的 → 生成新的 Task ID（延续现有编号）\n`;
+        p += `- 已有端不要重复拆分，只拆分**新增的端**\n`;
+        p += `- 已有 Task 的 _shared/ 目录保持不变，新端目录平铺追加到任务根目录下（如 \`{端名}/{taskId}-{端名}/\`）\n`;
+        p += `- API 契约（_shared/API_CONTRACT.yaml）需要补充新端涉及的接口\n\n`;
+    }
+    // v8.3.160+: 路径引用模式 —— 不再把文档全文塞进 Prompt，让 AI 通过 Read 工具按需读取
+    p += `## 📂 文档清单（请按需 Read）\n\n`;
+    p += `> 💡 **路径引用模式**：以下文档已就绪，请根据当前任务需要选择性 Read，不要一次性加载所有文件。\n\n`;
+    p += `### 必读文档\n\n`;
+    p += `1. \`CONSTITUTION.md\` — 技术宪法（端列表、命名规范、技术栈）\n`;
+    p += `2. \`010-requirements/INDEX.md\` — 需求全貌索引\n`;
+    p += `3. \`010-requirements/converted/*.md\` — 转换后的需求文档\n`;
+    p += `4. \`020-specs/overview/REQUIREMENT.md\` — 黄金需求文档\n`;
+    p += `5. \`020-specs/overview/TECH.md\` — 全局技术方案\n`;
+    p += `6. \`020-specs/overview/ANALYSIS.md\` — 功能分析\n`;
+    p += `7. \`020-specs/overview/FUNCTION_MAP.md\` — 功能单元与端的映射（参考，权威来源为 010-requirements/features/ 目录）\n`;
+    if (await (0, fs_extra_1.pathExists)((0, path_1.join)(iterationDir || '', '020-specs', 'overview', 'INTERACTION_MAP.md'))) {
+        p += `8. \`020-specs/overview/INTERACTION_MAP.md\` — 跨端交互时序\n`;
+    }
+    if (await (0, fs_extra_1.pathExists)((0, path_1.join)(iterationDir || '', '020-specs', 'overview', 'DEV_GUIDE.md'))) {
+        p += `9. \`020-specs/overview/DEV_GUIDE.md\` — 开发指南\n`;
+    }
+    p += `\n`;
+    p += `### 按功能模块读取（020-specs/{功能模块}/）\n\n`;
+    p += `对于每个功能模块，按需 Read：\n`;
+    for (const spec of specContents) {
+        p += `- \`020-specs/${spec.name}\`\n`;
+    }
+    p += `\n`;
+    p += `> 📖 **读取策略**：\n`;
+    p += `> - 先 Read 010-requirements/features/ 目录了解功能单元划分（权威来源），FUNCTION_MAP.md 作功能×端映射参考\n`;
+    p += `> - 按功能单元逐个处理，每次只 Read 当前单元相关的文档\n`;
+    p += `> - reqContent 从 REQUIREMENT.md 和对应功能模块的需求文档提取\n`;
+    p += `> - techContent 从 TECH.md 和对应功能模块的技术规格提取\n`;
+    p += `> - devGuideContent 从 DEV_GUIDE.md 提取\n\n`;
+    p += `---\n\n`;
+    // v6.69.3+: 注入标准端名列表
+    if (standardPlatforms.length > 0) {
+        p += `## 🖥️ 项目端列表（标准端名 — 权威来源）\n\n`;
+        p += `本项目已配置以下端，所有 scope 必须使用这些**标准端名**，禁止使用简写或中文：\n\n`;
+        p += `\`${standardPlatforms.join('`, `')}\`\n\n`;
+        p += `- ⛔ **禁止使用以下非标准端名**: \`api\`、\`web\`、\`backend\`、\`frontend\`、\`admin\`、\`h5\`、\"后端\"、\"前端\"\n`;
+        p += `- ✅ **必须使用 CONSTITUTION.md 中的标准端名**作为子任务目录名\n`;
+        p += `- scope 数组和子任务目录名必须完全匹配上述标准端名\n\n`;
+    }
+    // v7.4.2+: 功能单元精准上下文（CLI 提取，AI 拆分）
+    if (iterationDir) {
+        try {
+            const funcMapPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'FUNCTION_MAP.md');
+            let funcUnitsInjected = false;
+            if (await (0, fs_extra_1.pathExists)(funcMapPath)) {
+                const funcMapContent = await (0, fs_extra_1.readFile)(funcMapPath, 'utf-8');
+                const funcUnits = parseFunctionMap(funcMapContent, standardPlatforms);
+                if (funcUnits.length > 0) {
+                    p += `## 🧩 功能单元上下文（CLI 从 FUNCTION_MAP.md 精准提取）\n\n`;
+                    p += `> 以下是从 FUNCTION_MAP.md 中为每个功能单元提取的相关上下文。\n`;
+                    p += `> 拆分时必须基于这些功能单元，每个功能单元对应 1~3 个任务。\n\n`;
+                    for (const unit of funcUnits) {
+                        const unitCtx = await (0, unit_context_assembler_1.extractOverviewContext)(iterationDir, unit.name, unit.platforms);
+                        p += `### 📌 功能单元: ${unit.name}\n`;
+                        p += `- 涉及端: ${unit.platforms.join(', ')}\n`;
+                        if (unit.sharedCapability && unit.sharedCapability !== '无')
+                            p += `- 共享能力: ${unit.sharedCapability}\n`;
+                        if (unit.dependsOn && unit.dependsOn.length > 0)
+                            p += `- 依赖: ${unit.dependsOn.join(', ')}\n`;
+                        if (unit.description)
+                            p += `- 说明: ${unit.description}\n`;
+                        p += `\n${unitCtx}\n\n---\n\n`;
+                    }
+                    funcUnitsInjected = true;
+                }
+            }
+            // v7.5.0+: FUNCTION_MAP.md 不存在或为空时，从 ANALYSIS.md 提取功能单元清单
+            if (!funcUnitsInjected) {
+                const analysisPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'ANALYSIS.md');
+                if (await (0, fs_extra_1.pathExists)(analysisPath)) {
+                    const analysisContent = await (0, fs_extra_1.readFile)(analysisPath, 'utf-8');
+                    const analysisUnits = parseAnalysisFunctionalUnits(analysisContent, standardPlatforms);
+                    if (analysisUnits.length > 0) {
+                        p += `## 🧩 功能单元清单（CLI 从 ANALYSIS.md 提取，v7.5.0+）\n\n`;
+                        p += `> 以下是从 ANALYSIS.md 功能点清单表中提取的 **全部功能单元**（F-xx 编号）。\n`;
+                        p += `> ⚠️ **你必须为每个功能单元创建至少 1 个任务，不允许遗漏任何功能单元。**\n`;
+                        p += `> 可以按合并规则将相关功能单元合并为同一个任务，但必须确保所有功能单元都被覆盖。\n\n`;
+                        p += `| 编号 | 功能单元 | 涉及端 | 核心功能 |\n`;
+                        p += `|:---|:---|:---|:---|\n`;
+                        for (const u of analysisUnits) {
+                            p += `| ${u.id} | ${u.name} | ${u.platforms.join(', ')} | ${u.description || '-'} |\n`;
+                        }
+                        p += `\n**拆分要求**：\n`;
+                        p += `- 每个功能单元必须在某个任务的 \`functionalUnit\` 字段中被引用\n`;
+                        p += `- 合并时，在任务描述中列出所有合并的功能单元编号（如 F-02, F-03）\n`;
+                        p += `- 不允许将不同端的功能单元合并到同一个任务\n\n`;
+                    }
+                }
+                // v8.3.220+: FUNCTION_MAP 和 ANALYSIS 都为空/骨架时，回退到 features/ 目录（功能单元权威来源）
+                if (!funcUnitsInjected) {
+                    const featureDirs = await (0, spec_paths_1.parseFeatureList)(iterationDir);
+                    if (featureDirs.length > 0) {
+                        p += `## 🧩 功能单元清单（CLI 从 010-requirements/features/ 目录提取，v8.3.220+）\n\n`;
+                        p += `> 以下是从 features/ 目录读取的 **全部功能单元**（权威来源）。\n`;
+                        p += `> ⚠️ **你必须为每个功能单元创建至少 1 个任务，不允许遗漏任何功能单元。**\n\n`;
+                        p += `| 功能单元 |\n`;
+                        p += `|:---|\n`;
+                        for (const fn of featureDirs) {
+                            p += `| ${fn} |\n`;
+                        }
+                        p += `\n**拆分要求**：\n`;
+                        p += `- 每个功能单元必须在某个任务的 \`functionalUnit\` 字段中被引用\n`;
+                        p += `- 涉及端从 CONSTITUTION.md 端列表判断，或从 features/{单元}/.meta/source 读取\n\n`;
+                        funcUnitsInjected = true;
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    // SpecCore 拆分原则
+    p += `## ⚙️ SpecCore 拆分原则\n\n`;
+    p += `SpecCore 核心理念: "Code by Spec, Not by Vibe" — 每个任务必须有对应的 Spec，AI 在 Spec 约束下工作。\n\n`;
+    p += `### 原子任务定义\n`;
+    p += `一个原子任务 = 一个开发者在指定粒度内可独立完成的、有明确验收标准的最小工作单元。\n`;
+    p += `判定标准（全部满足）:\n`;
+    p += `- 有独立的输入/输出（API 接口 / 页面 / 数据表）\n`;
+    p += `- _shared/ + {端}/TASK.md 能独立写满（REQ.md + TECH.md + 各端子任务）\n`;
+    p += `- execute 时不强依赖其他 Task 的运行时状态\n`;
+    p += `- 有明确的验收标准（AC 可枚举）\n`;
+    p += `- 可独立提 PR、独立 review\n\n`;
+    p += `### 合并规则（优先合并，减少任务数）\n`;
+    p += `- 同一数据实体的 CRUD → 共享数据模型，合并为 1 个任务\n`;
+    p += `- 页面 + 对应后端接口 < 5 个 → 前后端强耦合，一人做效率最高\n`;
+    p += `- 纯配置/文案/样式微调 → 不构成独立工作单元\n`;
+    p += `- 关联紧密的小功能（如列表页 + 详情页）→ 共享路由和状态\n`;
+    p += `- **复杂度判断**：如果一个需求章节接口 ≤ 3、数据表 ≤ 1、预估工时 < 粒度下限 → 必须合并到最相关的任务，不单独拆\n`;
+    p += `- **宁少勿多**：任务数越少越好，每个任务应该是真正独立的工作单元。如果两个功能共享数据模型或路由，一人就能做完，不要拆\n\n`;
+    p += `### 拆分规则\n`;
+    p += `- 超出当前粒度接口上限 → 按业务领域拆\n`;
+    p += `- 超出当前粒度数据表上限 → 按数据层拆\n`;
+    p += `- 超出当前粒度工时上限 → 必须再拆\n`;
+    p += `- 低于当前粒度工时下限 → 合并到关联任务\n`;
+    p += `- 跨端功能 → 按端拆（后端 1 个 + 每个前端各 1 个）\n`;
+    p += `- 独立第三方集成（支付/短信/OSS）→ 独立任务\n\n`;
+    // 聚合度分析（v6.43.0+）
+    p += `### 🔍 功能聚合度分析（重要 — 拆分前必须执行）\n\n`;
+    p += `对 REQUIREMENT.md 中的每个功能模块，判断它是「聚合的」还是「单端的」：\n\n`;
+    p += `**聚合功能**（涉及多个端）：\n`;
+    p += `- 判定标准：功能的「涉及端」列包含 2 个以上端，或功能描述中涉及多端交互\n`;
+    p += `- 拆分策略：**按端拆分**，每个端一个独立 Task\n`;
+    p += `  - 例：「用户登录」涉及 h5 + backend + admin → 拆成 3 个 Task：\n`;
+    p += `    - Task-NNN-h5-login（h5 端登录页面 + 交互）\n`;
+    p += `    - Task-NNN-backend-login（登录接口 + 鉴权 + 数据模型）\n`;
+    p += `    - Task-NNN-admin-login（管理端登录入口）\n`;
+    p += `  -  错误示例：Task-116-approval-scheduler（跨端功能未拆分）\n`;
+    p += `  - ✅ 正确做法：Task-116-approval-backend + Task-117-approval-admin + Task-118-approval-h5\n`;
+    p += `  - 共享契约：\`_shared/API_CONTRACT.yaml\` 定义跨端接口\n`;
+    p += `  - 每个 Task 的 scope 只包含该端，不要跨端\n\n`;
+    p += `**单端功能**（只涉及一个端）：\n`;
+    p += `- 直接生成 1 个 Task，scope 只包含该端\n`;
+    p += `- 但仍需检查隐含跨端依赖（如 admin 页面需要 backend 提供新接口）\n`;
+    p += `- 如有隐含依赖，在 dependencies 中标注，或在 scope 中加入对应端\n\n`;
+    p += `**判断流程**：\n`;
+    p += `1. 读 overview/REQUIREMENT.md 的功能模块清单 → 查看「涉及端」列\n`;
+    p += `2. 读 overview/ANALYSIS.md → 确认跨端关联和数据流向\n`;
+    p += `3. 读 overview/TECH.md → 了解整体架构中的端交互\n`;
+    p += `4. 对每个功能模块判定聚合度，决定拆分策略\n\n`;
+    // 类型文档 1:1 映射规则
+    p += `### 类型文档拆分规则（bugs/refactors/research）\n`;
+    p += `与 feature 不同，类型文档采用 **1:1 映射**——每个文档直接对应一个任务，不拆分不合并：\n`;
+    p += `- \`bugs/xxx.md\` → 1 个 bugfix 任务（一个 bug 就是一个任务，不要把多个 bug 合并）\n`;
+    p += `- \`refactors/xxx.md\` → 1 个 refactor 任务\n`;
+    p += `- \`research/xxx.md\` → 1 个 research 任务\n`;
+    p += `- \`features/xxx.md\` → 按功能单元拆分规则处理（可能 1~3 个 feature 任务）\n`;
+    p += `- **sourceFile 必须填写**：类型文档任务的 sourceFile 就是该文档的相对路径（如 \`bugs/login-timeout.md\`）\n\n`;
+    p += `### 依赖关系\n`;
+    p += `- 基础模块（认证/数据库/配置）优先拆出，作为第一批任务\n`;
+    p += `- 依赖链深度 ≤ 3\n`;
+    p += `- 同层级无循环依赖\n\n`;
+    p += `### 总量约束（功能单元基准）\n`;
+    p += `- 核心原则：以需求的功能单元为基准拆分，而非需求文档的章节划分\n`;
+    p += `- 每个功能单元默认 1 个任务，最多 3 个\n`;
+    p += `- 单次迭代总任务数**不得超过 20 个**（超出说明粒度过细，必须合并）\n`;
+    p += `- 每个任务必须有明确的 owner（对应 STAFFING 中的成员）\n`;
+    p += `- 高优先级任务排在前面\n`;
+    p += `- 没有实质性功能内容的章节（如背景、概述、架构、术语等）不能作为拆分依据\n\n`;
+    // v8.3.160+: 根据 subagent 动态调整本步骤任务指令
+    if (subagent === 'dependency-analyst') {
+        p += `## 🔗 本步骤任务：依赖关系分析\n\n`;
+        p += `你是 **依赖关系分析师**。你的职责是分析任务间的依赖关系，不需要做拆分或工时估算。\n\n`;
+        p += `**输入**：上一步生成的任务列表（含 id、name、functionalUnit、scope）\n`;
+        p += `**输出**：为每个任务补充 \`dependencies\` 字段，标注该任务依赖哪些其他任务（填写 task id）\n\n`;
+        p += `### 依赖判定规则\n\n`;
+        p += `- **数据依赖**：Task-B 需要 Task-A 创建的数据表/实体 → B 依赖 A\n`;
+        p += `- **API 依赖**：Task-B 调用 Task-A 提供的接口 → B 依赖 A\n`;
+        p += `- **状态依赖**：Task-B 需要 Task-A 完成后的某个业务状态 → B 依赖 A\n`;
+        p += `- **配置依赖**：Task-B 需要 Task-A 完成后的配置/环境 → B 依赖 A\n`;
+        p += `- 依赖链深度 ≤ 3，发现循环依赖必须标注并建议解耦方案\n`;
+        p += `- 同层级任务之间尽量无依赖，可并行执行\n\n`;
+    }
+    else if (subagent === 'effort-estimator') {
+        p += `## ⏱️ 本步骤任务：工时估算与排期\n\n`;
+        p += `你是 **工时估算专家**。你的职责是为每个任务估算工时并确定优先级，不需要重新拆分。\n\n`;
+        p += `**输入**：带依赖关系的任务列表（含 id、name、scope、dependencies）\n`;
+        p += `**输出**：为每个任务补充 \`estimatedHours\`、\`priority\`、\`owner\` 字段\n\n`;
+        p += `### 估算规则\n\n`;
+        p += `- 单个任务工时控制在 **2h-8h** 之间\n`;
+        p += `- 超过 8h 必须拆分为多个任务（返回修改建议，不要硬估）\n`;
+        p += `- 低于 2h 建议合并到关联任务\n`;
+        p += `- **高优先级**：基础模块（认证/数据库/配置）、被多个任务依赖的任务\n`;
+        p += `- **中优先级**：核心业务功能\n`;
+        p += `- **低优先级**：独立第三方集成、纯 UI 调整\n`;
+        p += `- 考虑技术风险和不确定性，预留 20% 缓冲\n\n`;
+    }
+    else {
+        // task-decomposer 默认
+        p += `## 📋 本步骤任务：任务拆分与内容生成\n\n`;
+        p += `你是 **任务拆分专家**。你的职责是将功能模块拆分为原子级开发任务，并为每个任务生成完整的内容。\n\n`;
+        p += `**核心要求**：\n`;
+        p += `- 按 FUNCTION_MAP.md 中的功能单元拆分\n`;
+        p += `- 每个功能单元涉及的端，各生成一个子任务（scope 只包含该端）\n`;
+        p += `- 为每个任务生成完整的 reqContent、techContent、devGuideContent\n`;
+        p += `- **内容必须从 020-specs/ 对应文档中读取并提取**，禁止输出模板化占位符\n`;
+        p += `- 如果某个文档内容不足，标注「基于现有信息推断」而非留空\n\n`;
+    }
+    // 输出格式
+    p += `## 📤 输出格式\n\n`;
+    p += `请输出 JSON 数组，每个 Task 包含:\n`;
+    p += '```json\n';
+    p += `[\n  {\n`;
+    p += `    "id": "Task-001",\n`;
+    p += `    "functionalUnit": "所属功能单元/影响域（必填！见下方类型规则）",\n`;
+    p += `    "name": "任务名称（中文）",\n`;
+    p += `    "topic": "english-slug-for-directory",\n`;
+    p += `    "type": "feature|bugfix|refactor|research|security|performance",\n`;
+    p += `    "reason": "为什么这样拆分",\n`;
+    p += `    "scope": ["booking-service", "admin-web"],\n`;
+    p += `    "priority": "high|medium|low",\n`;
+    p += `    "dependencies": [],\n`;
+    p += `    "acceptanceCriteria": ["AC1: ..."],\n`;
+    p += `    "risk": "low|medium|high",\n`;
+    p += `    "owner": "建议负责人",\n`;
+    p += `    "sourceFile": "来源文档路径（如 bugs/login-timeout.md、features/user-auth.md）",\n`;
+    p += `    "reqContent": "需求描述内容（Markdown 格式，写入 REQ.md）",\n`;
+    p += `    "techContent": "技术方案内容（Markdown 格式，写入 TECH.md）",\n`;
+    p += `    "devGuideContent": "开发者实现指南（Markdown 格式，写入 DEV_GUIDE.md）：实现步骤、关键代码示例、与存量功能集成、注意事项"\n`;
+    p += `  }\n]\n`;
+    p += '```\n\n';
+    p += `> **functionalUnit 必须填写**：根据任务类型语义不同：\n`;
+    p += `>   - feature → 功能模块名（如：用户管理、订单系统、支付模块）\n`;
+    p += `>   - bugfix → 受影响组件/流程（如：登录流程、支付回调、数据同步）\n`;
+    p += `>   - refactor → 重构目标范围（如：数据库层、API网关、状态管理）\n`;
+    p += `>   - security → 安全修复范围（如：SQL注入防护、XSS修复、鉴权加固）\n`;
+    p += `>   - performance → 性能优化目标（如：查询优化、缓存策略、并发提升）\n`;
+    p += `>   - research → 研究主题（如：WebSocket方案、缓存策略）\n`;
+    p += `> 同一模块/领域的任务填相同的值，用于粒度校验和任务分组\n`;
+    p += `> **topic 必填且必须是英文短横线格式**：\n`;
+    p += `>   - 用于生成任务目录名 \`Task-NNN-{topic}\`，如 \`Task-001-user-auth\`\n`;
+    p += `>   - 从功能单元名提取英文关键词拼接，如：\n`;
+    p += `>     - "用户认证" → \`user-authentication\`\n`;
+    p += `>     - "订单CRUD" → \`order-crud\`\n`;
+    p += `>     - "支付模块" → \`payment-module\`\n`;
+    p += `>   - 格式：全小写、短横线连接，如 \`user-auth\`、\`order-list\`\n`;
+    p += `>   - ⛔ 禁止纯中文、禁止空值、禁止驼峰命名、禁止下划线\n`;
+    p += `>   - 如果功能单元名完全没有英文可提取，用简写英文意译（如"会议室预订" → \`room-booking\`）\n`;
+    p += `> **sourceFile** 必须填写：该任务对应的 020-specs 源文档路径（如 \`bugs/login-timeout.md\`、\`features/user-auth.md\`、\`refactors/db-pool.md\`），用于在 CONTEXT.md 中生成来源追溯\n`;
+    p += `> **scope 强制约束（违反则拆分无效）**：\n`;
+    p += `>   - scope 数组中的每个值必须是上面「项目端列表」中的标准端名之一\n`;
+    p += `>   - ⛔ 禁止出现 api、web、backend、frontend、server、admin、h5、mobile、pc、app 等非标准名称\n`;
+    p += `>   - ⛔ 禁止出现中文端名（如"后端"、"前端"、"移动端"）\n`;
+    p += `>   - 每个任务按 scope 中的端创建子任务目录，目录名 = 标准端名\n`;
+    p += `>   - 如果 scope 含非标准端名，整个 JSON 视为不合格，必须重新生成\n`;
+    p += `> **reqContent 质量要求（必填，禁止模板化）**：\n`;
+    p += `>   - 必须是**具体的、可执行的需求描述**，不是"待补充"或"参考全局文档"\n`;
+    p += `>   - 包含：业务规则（含边界条件）、数据模型（字段/类型/约束）、接口清单（方法/路径/参数/响应）\n`;
+    p += `>   - 从 020-specs/overview/REQUIREMENT.md 和 020-specs/{功能模块}/{对应端}/TECH.md 中提取本任务相关的具体内容\n`;
+    p += `>   - 直接写入 00-specs/REQ.md，执行时 AI 不再重新分析需求\n`;
+    p += `> **techContent 质量要求（必填，禁止模板化）**：\n`;
+    p += `>   - 必须是**具体的技术实现方案**，不是框架模板\n`;
+    p += `>   - 包含：架构设计、核心逻辑伪代码/流程、数据库设计（表结构/索引）、API 详细定义、测试策略\n`;
+    p += `>   - 从 020-specs/overview/TECH.md 和 020-specs/{功能模块}/{对应端}/TECH.md 中提取本任务相关的技术细节\n`;
+    p += `>   - 直接写入 00-specs/TECH.md，执行时 AI 据此直接开发\n`;
+    p += `> **质量红线**：如果 reqContent/techContent 只有标题和占位符（如 "<!-- AI-FILL -->"），视为不合格，必须重新生成\n\n`;
+    // v8.3.4+: 强制约束专节（类似 analyze Phase 2）
+    p += `### ⛔ 强制约束（违反则拆分无效）\n\n`;
+    p += `- **禁止跳过任何功能模块** — 即使某个模块信息不足，也必须基于已有信息拆分并填充 reqContent/techContent，标注「基于现有信息推断」而非留空\n`;
+    p += `- **禁止输出空内容** — reqContent、techContent、devGuideContent 每个字段长度必须 ≥200 字符，不允许写「待补充」「TODO」「参考全局文档」\n`;
+    p += `- **禁止省略字段** — JSON 中必须包含 reqContent、techContent、devGuideContent 三个字段，缺一不可\n`;
+    p += `- **内容必须从 analyze 产物提取** — reqContent 从 REQUIREMENT.md 提取，techContent 从 TECH.md 提取，devGuideContent 从 DEV_GUIDE.md 提取\n`;
+    p += `- **如果 token 不足**：优先保证 reqContent 完整，其次是 techContent，最后是 devGuideContent\n\n`;
+    p += `### ⚠️ 拆分规则（重要）\n\n`;
+    p += `- **按功能单元拆分，不按技术层拆分**：每个任务必须对应一个业务功能（如「预订管理」「签到」「审批」），不要按技术层分组（如「后端改进」「前端修复」）\n`;
+    p += `- ❌ 错误示例：Task-129-backend-improve、Task-130-admin-fix（按技术层分组）\n`;
+    p += `- ✅ 正确示例：Task-129-booking-crud、Task-130-checkin-flow、Task-131-approval-management（按功能单元分组）\n`;
+    p += `- **topic 必须反映功能单元**：每个任务的 topic（目录名后缀）必须唯一且反映业务功能，禁止所有任务都用同一个后缀（如 -impl）\n`;
+    p += `- **scope 必须使用标准端名**：禁止使用 api/web/backend/frontend 等非标准名称\n`;
+    p += `- **一个功能单元默认 1 个任务**，最多拆成 3 个\n`;
+    p += `- **按 scope 涉及的端创建子任务**：每个端 1 个子任务目录\n\n`;
+    // 质量自检
+    p += `## ✅ 质量自检（必须全部通过）\n\n`;
+    p += `□ 每个任务都满足原子任务定义？\n`;
+    p += `□ **每个任务按功能单元命名，不是按技术层**？（禁止 backend-improve/admin-fix 这类名称）\n`;
+    p += `□ **每个 topic 唯一且反映业务功能**？（禁止全部用 -impl）\n`;
+    p += `□ **scope 只包含 CONSTITUTION.md 标准端名**？（禁止 api/web/backend/frontend）\n`;
+    p += `□ 没有循环依赖？\n`;
+    p += `□ 基础模块排在前面？\n`;
+    p += `□ 同功能单元内的任务没被过度拆分？（每个功能单元 ≤ 3 个任务）\n`;
+    p += `□ 总任务数不超过 20 个？\n`;
+    p += `□ 没有把非功能章节（背景/概述/架构/术语）作为拆分依据？\n`;
+    p += `□ 每个任务都有明确的 owner 和 acceptanceCriteria？\n`;
+    p += `□ 每个任务都能独立提 PR、独立 review？\n`;
+    // 自动模式指令
+    p += `## 🤖 自动模式指令\n\n`;
+    p += `本拆分在自动模式下执行，请遵循以下原则:\n`;
+    p += `1. **不要询问用户** — 按你的最佳判断直接拆分，不要请求确认或澄清\n`;
+    p += `2. **有疑问就记录** — 如果对需求理解、技术选型、任务边界有疑问，不要停下来问，而是:\n`;
+    p += `   - 按你的最佳判断继续拆分\n`;
+    p += `   - 将疑问写入 \`.speccore/questions/split-{迭代名}-{日期}.md\`\n`;
+    p += `   - 格式: \`## 疑问 N
+- 问题描述
+- 你的判断
+- 建议后续动作\`
+`;
+    p += `3. **禁止跳过任何模块** — 即使某个功能模块信息不足，也必须基于已有信息拆分并填充内容，宁可标注「基于现有信息推断：需要补充 xxx」也不许留空或省略\n`;
+    p += `4. **输出 JSON** — 直接输出拆分结果的 JSON 数组，不要输出其他内容\n`;
+    // 持久指令（用户调整时 AI 可回读此文件）
+    p += `\n## 🔄 调整指令（持久有效）\n\n`;
+    p += `当用户要求调整拆分方案时（如“合并”“拆分”“改工时”“改优先级”）：\n`;
+    p += `1. **先重读本文件** — 本文件包含完整的拆分规则、粒度约束、端配置、Spec 上下文\n`;
+    p += `2. **在同一套规则下调整** — 合并/拆分/修改都必须遵守粒度硬约束\n`;
+    p += `3. **重新输出完整 JSON** — 不要只输出修改的部分，输出调整后的完整数组\n`;
+    p += `4. **文件路径**: \`.speccore/prompts/split-suggestion-${iteration}.md\`\n\n`;
+    return p;
+}
+/**
+ * 读取迭代的 STAFFING.md 人员排期配置
+ */
+function readStaffing(iterationDir) {
+    try {
+        const staffingPath = (0, path_1.join)(iterationDir, 'STAFFING.md');
+        if (!require('fs').existsSync(staffingPath))
+            return null;
+        const content = require('fs').readFileSync(staffingPath, 'utf-8');
+        const members = [];
+        // 解析表格: | 张三 | 后台 | 70% |
+        const lines = content.split(/\r?\n/);
+        for (const line of lines) {
+            if (!line.startsWith('|') || line.includes(':---'))
+                continue;
+            const cols = line.split('|').map((c) => c.trim()).filter(Boolean);
+            if (cols.length >= 3 && cols[0] !== '人员' && cols[0] !== '成员') {
+                const capacity = parseInt(cols[2] || '100') || 100;
+                members.push({
+                    name: cols[0],
+                    platforms: (cols[1] || '').split(/[,，]/).map((p) => p.trim()),
+                    capacity,
+                });
+            }
+        }
+        return members.length > 0 ? members : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 根据平台和负荷自动推荐负责人
+ */
+function autoAssign(section, platforms, staffing) {
+    const targetPlatform = section.platform || '';
+    if (!targetPlatform || !staffing.length)
+        return '未分配';
+    // 找到匹配平台的、负荷最低的人
+    let best = null;
+    let bestLoad = Infinity;
+    for (const m of staffing) {
+        const platformMatch = m.platforms.some(p => targetPlatform.includes(p) || p.includes(targetPlatform));
+        if (platformMatch && m.capacity < bestLoad) {
+            best = m;
+            bestLoad = m.capacity;
+        }
+    }
+    return best ? best.name : '未分配';
+}
+/**
+ * 分析章节复杂度，决定优先级和工时（简化版）
+ */
+function estimateSectionComplexity(section) {
+    const content = section.content || '';
+    const name = section.name || '';
+    const full = `${name}\n${content}`;
+    // 粗略估算工时（仅用于展示）
+    const wordCount = full.length;
+    const estimatedHours = wordCount > 800 ? 16 : wordCount > 300 ? 8 : 4;
+    // 优先级
+    let priority = 'medium';
+    if (full.includes('核心') || full.includes('基础') || full.includes('安全')) {
+        priority = 'high';
+    }
+    else if (wordCount < 200) {
+        priority = 'low';
+    }
+    return { estimatedHours, priority };
+}
+/**
+ * 语义依赖检测: 比字符串匹配更准确的任务间关系
+ */
+function detectSemanticDependencies(sections) {
+    const deps = new Map();
+    // 关键词对: [from, to]
+    const semanticPairs = [
+        [/订单|支付|交易/, /用户|登录|认证|鉴权/, '需要用户模块'],
+        [/管理|后台|admin/, /用户|登录|认证/, '需要登录鉴权'],
+        [/列表|查询|搜索/, /数据库|表|DDL|schema/, '依赖数据表'],
+        [/页面|界面|UI|表单/, /API|接口|后端/, '依赖后端接口'],
+        [/统计|报表|dashboard/, /列表|查询|数据/, '依赖数据查询'],
+        [/通知|消息|推送|email/, /用户|人员|member/, '依赖用户数据'],
+        [/文件|上传|下载|附件/, /存储|oss|s3|bucket/, '依赖存储服务'],
+        [/审批|审核|workflow/, /用户|角色|权限/, '依赖用户角色'],
+    ];
+    for (let i = 0; i < sections.length; i++) {
+        const si = sections[i];
+        const siContent = `${si.name}\n${si.content || ''}`;
+        const taskDeps = [];
+        for (let j = 0; j < sections.length; j++) {
+            if (i === j)
+                continue;
+            const sj = sections[j];
+            const sjContent = `${sj.name}\n${sj.content || ''}`;
+            // 语义匹配
+            for (const [fromPat, toPat, reason] of semanticPairs) {
+                if (fromPat.test(siContent) && toPat.test(sjContent)) {
+                    const depLabel = `${sections[j]._taskId || `Task-${String(j + 1).padStart(3, '0')}`}(${sj.name.slice(0, 10)})`;
+                    if (!taskDeps.includes(depLabel))
+                        taskDeps.push(depLabel);
+                    break; // 每对只匹配一次
+                }
+            }
+        }
+        if (taskDeps.length > 0) {
+            deps.set(sections[i]._taskId || `Task-${String(i + 1).padStart(3, '0')}`, taskDeps);
+        }
+    }
+    return deps;
+}
+async function detectExistingTasks(iterDir) {
+    const tasks = [];
+    // 优先从 030-tasks/ 扫描
+    const scanDir = (0, path_1.join)(iterDir, '030-tasks');
+    const targetDir = (await (0, fs_extra_1.pathExists)(scanDir)) ? scanDir : iterDir;
+    const scanRecursive = async (dir) => {
+        try {
+            const entries = await (0, fs_extra_1.readdir)(dir, { withFileTypes: true });
+            for (const e of entries) {
+                if (e.isDirectory()) {
+                    if (e.name.startsWith('Task-')) {
+                        tasks.push(e.name);
+                    }
+                    else if (!e.name.startsWith('.')) {
+                        // 递归扫描类型子目录（feature/bugfix/refactor/research）
+                        await scanRecursive((0, path_1.join)(dir, e.name));
+                    }
+                }
+            }
+        }
+        catch { }
+    };
+    await scanRecursive(targetDir);
+    return tasks;
+}
+/**
+ * v8.3.24+: 扫描已有 Task 的端结构
+ * 返回每个 Task 已有的端目录（端平铺结构: {端名}/）
+ */
+async function scanExistingTaskStructure(iterDir) {
+    const result = new Map();
+    const tasks = await detectExistingTasks(iterDir);
+    const standardPlatforms = await (0, spec_paths_1.parsePlatformList)();
+    for (const taskName of tasks) {
+        // 递归查找实际任务目录（支持 030-tasks/{type}/Task-xxx/ 布局）
+        const tasksRoot = (0, path_1.join)(iterDir, '030-tasks');
+        let taskDir = (0, path_1.join)(tasksRoot, taskName);
+        if (!(await (0, fs_extra_1.pathExists)(taskDir))) {
+            // 可能在类型子目录下
+            try {
+                const entries = await (0, fs_extra_1.readdir)(tasksRoot, { withFileTypes: true });
+                for (const e of entries) {
+                    if (e.isDirectory() && !e.name.startsWith('.')) {
+                        const candidate = (0, path_1.join)(tasksRoot, e.name, taskName);
+                        if (await (0, fs_extra_1.pathExists)(candidate)) {
+                            taskDir = candidate;
+                            break;
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        if (!(await (0, fs_extra_1.pathExists)(taskDir)))
+            continue;
+        const platforms = [];
+        // v8.3.24+: 扫描端平铺结构 — 任务目录下的合法端名子目录
+        try {
+            const entries = await (0, fs_extra_1.readdir)(taskDir, { withFileTypes: true });
+            for (const e of entries) {
+                if (e.isDirectory() && !e.name.startsWith('.') && !e.name.startsWith('_') && standardPlatforms.includes(e.name)) {
+                    platforms.push(e.name);
+                }
+            }
+        }
+        catch { }
+        if (platforms.length > 0) {
+            result.set(taskName, platforms);
+        }
+    }
+    return result;
+}
+/**
+ * 生成任务总览报告 → 000-overview/TASK_SUMMARY.md
+ * 包含：任务名、功能单元、人工工时、AI工时、优先级、依赖、风险
+ */
+async function generateTaskSummary(iterationDir, tasks, createdSections) {
+    const today = new Date().toISOString().split('T')[0];
+    let md = `# 任务总览报告\n\n`;
+    md += `> 生成时间: ${today} | 任务总数: ${createdSections.length}\n\n`;
+    // 汇总表
+    md += `## 任务清单\n\n`;
+    md += `| # | 任务名 | 功能单元 | 人工工时 | AI工时 | 优先级 | 依赖 | 风险 |\n`;
+    md += `| :--- | :--- | :--- | ---: | ---: | :---: | :--- | :---: |\n`;
+    let totalHumanHours = 0;
+    let totalAiHours = 0;
+    for (let i = 0; i < createdSections.length; i++) {
+        const task = tasks[i] || {};
+        const sec = createdSections[i];
+        const taskId = sec._taskId || `Task-${String(i + 1).padStart(3, '0')}`;
+        const name = sec.name || task.name || '';
+        const unit = task.functionalUnit || '(未标注)';
+        const estimatedHours = task.estimatedHours || sec._complexity?.estimatedHours || 0;
+        // AI 工时 = estimatedHours 中标注为 AI 可自动完成的部分（目前全部算 AI 工时）
+        const aiHours = Math.round(estimatedHours * 0.7); // 预估 70% 可由 AI 完成
+        const humanHours = estimatedHours - aiHours;
+        const priority = task.priority || sec._complexity?.priority || 'medium';
+        const deps = (task.dependencies || []).join(', ') || '-';
+        const risk = task.risk || 'medium';
+        totalHumanHours += humanHours;
+        totalAiHours += aiHours;
+        const priorityIcon = priority === 'high' ? '🔴' : priority === 'low' ? '🟢' : '🟡';
+        const riskIcon = risk === 'high' ? '🔴' : risk === 'low' ? '🟢' : '🟡';
+        md += `| ${taskId} | ${name} | ${unit} | ${humanHours}h | ${aiHours}h | ${priorityIcon} ${priority} | ${deps} | ${riskIcon} ${risk} |\n`;
+    }
+    // 汇总
+    md += `\n## 工时汇总\n\n`;
+    md += `| 指标 | 值 |\n| :--- | ---: |\n`;
+    md += `| 人工总工时 | **${totalHumanHours}h** |\n`;
+    md += `| AI总工时 | **${totalAiHours}h** |\n`;
+    md += `| 总预估工时 | **${totalHumanHours + totalAiHours}h** |\n`;
+    md += `| AI 占比 | **${totalHumanHours + totalAiHours > 0 ? Math.round(totalAiHours / (totalHumanHours + totalAiHours) * 100) : 0}%** |\n`;
+    // 功能单元分布
+    const unitCounts = {};
+    for (const task of tasks.slice(0, createdSections.length)) {
+        const unit = task.functionalUnit || '(未标注)';
+        unitCounts[unit] = (unitCounts[unit] || 0) + 1;
+    }
+    md += `\n## 功能单元分布\n\n`;
+    md += `| 功能单元 | 任务数 |\n| :--- | ---: |\n`;
+    for (const [unit, count] of Object.entries(unitCounts)) {
+        md += `| ${unit} | ${count} |\n`;
+    }
+    // 写入文件（带时间戳，放单独子目录）
+    const overviewDir = (0, path_1.join)(iterationDir, '000-overview', 'task-summaries');
+    await (0, fs_extra_1.ensureDir)(overviewDir);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 16); // 2026-08-13T14-30
+    const summaryPath = (0, path_1.join)(overviewDir, `TASK_SUMMARY-${timestamp}.md`);
+    await (0, fs_extra_1.writeFile)(summaryPath, md);
+    return md;
+}
+/**
+ * 输出 [SPECCORE_NEXT_STEPS] 标记，引导宿主 AI 对每个 Task 执行 analyze --task
+ * split 完成后调用，生成任务级 00-specs/ 文档
+ */
+function outputAnalyzeTaskHints(iteration, sections) {
+    if (sections.length === 0)
+        return;
+    const iterFlag = iteration ? ` -I ${iteration}` : '';
+    let md = `\n## 🧠 下一步：任务级 Spec 分析\n\n`;
+    md += `拆分完成！每个 Task 需要执行 AI 分析，生成任务级 00-specs/ 文档（REQ.md、TECH.md、TASK.md、SCHEMA.md）。\n\n`;
+    md += `AI 会 Read global/ 和 {端}/ 的全局 spec 作为参考，根据本 Task 的原子范围生成针对性分析。\n\n`;
+    md += `### 执行命令\n\n`;
+    for (const sec of sections) {
+        const taskId = sec._taskId || sec.name;
+        md += `\`\`\`bash
+speccore analyze --task ${taskId}${iterFlag}
+\`\`\`
+
+`;
+    }
+    md += `> 自动模式可逐个执行，或告诉 AI：“对所有新建 Task 执行 analyze --task”\n`;
+    process.stdout.write('\n[SPECCORE_NEXT_STEPS]\n');
+    process.stdout.write(md);
+    process.stdout.write('\n[/SPECCORE_NEXT_STEPS]\n');
+}
+// ── v6.49.14+: 模块驱动拆分 — 从 overview/REQUIREMENT.md 读取涉及端 ──
+/**
+ * 从 overview/REQUIREMENT.md 解析功能模块清单的「涉及端」列
+ * 支持两种格式：
+ *   1. 单表格含「涉及端」列（功能模块 | 涉及端 | ...）
+ *   2. 按端分节（### X.X ... — {platform} 后跟表格）
+ * 返回模块列表及其涉及的标准端名
+ */
+function parseModulePlatforms(content, allPlatforms) {
+    // v7.4.2+: 先尝试原始格式（单表格含「涉及端」列）
+    const tableResult = parseModulePlatformsTable(content, allPlatforms);
+    if (tableResult.length > 0)
+        return tableResult;
+    // v7.4.2+: 回退到按端分节格式
+    return parseModulePlatformsBySection(content, allPlatforms);
+}
+/**
+ * v7.4.2+: 解析单表格含「涉及端」列的格式
+ */
+function parseModulePlatformsTable(content, allPlatforms) {
+    const modules = [];
+    const lines = content.split(/\r?\n/);
+    let inFeatureTable = false;
+    let platformColIdx = -1;
+    for (const line of lines) {
+        if (line.includes('功能模块清单')) {
+            inFeatureTable = true;
+            continue;
+        }
+        if (!inFeatureTable)
+            continue;
+        if (line.startsWith('## ') && !line.includes('功能模块清单'))
+            break;
+        const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+        if (cells.length < 2)
+            continue;
+        if (cells.some(c => c.includes('涉及端'))) {
+            platformColIdx = cells.findIndex(c => c.includes('涉及端'));
+            continue;
+        }
+        if (cells.every(c => /^[-:]+$/.test(c)))
+            continue;
+        const moduleName = cells[1];
+        if (!moduleName || moduleName === '#' || moduleName === '模块')
+            continue;
+        if (platformColIdx >= 0 && platformColIdx < cells.length) {
+            const raw = cells[platformColIdx];
+            if (raw && raw !== '_待 AI 标注_' && raw !== '—' && raw !== '-') {
+                const platforms = raw.split(/[,，]/)
+                    .map(p => p.trim())
+                    .filter(p => p && allPlatforms.includes(p));
+                if (platforms.length > 0) {
+                    modules.push({ name: moduleName, platforms });
+                    continue;
+                }
+            }
+        }
+        modules.push({ name: moduleName, platforms: [...allPlatforms] });
+    }
+    return modules;
+}
+/**
+ * v7.4.2+: 解析按端分节的 REQUIREMENT.md 格式
+ * 匹配: ### 2.1 后端 — booking-service 或 ### 2.1 前端 — admin-web
+ * 从标题提取端名，从后续表格提取模块名，建立模块→端的映射
+ */
+function parseModulePlatformsBySection(content, allPlatforms) {
+    const lines = content.split(/\r?\n/);
+    // 模块名 → 涉及端列表 的映射
+    const modulePlatformMap = new Map();
+    let currentPlatform = '';
+    let inTable = false;
+    for (const line of lines) {
+        // 检测按端分节标题: ### 2.1 后端 — booking-service
+        const sectionMatch = line.match(/^###\s+[\d.]+\s+.*[—\-–]\s*(.+)$/);
+        if (sectionMatch) {
+            const rawPlatform = sectionMatch[1].trim();
+            // 匹配标准端名
+            currentPlatform = allPlatforms.find(p => rawPlatform.includes(p)) || '';
+            inTable = false;
+            continue;
+        }
+        // 非当前端标题下的 ## 标题 → 重置
+        if (line.startsWith('## ') && !line.startsWith('### ')) {
+            currentPlatform = '';
+            inTable = false;
+            continue;
+        }
+        if (!currentPlatform)
+            continue;
+        // 检测表格开始（表头行含「功能模块」）
+        const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+        if (cells.length >= 2 && cells.some(c => c.includes('功能模块'))) {
+            inTable = true;
+            continue;
+        }
+        if (!inTable)
+            continue;
+        // 分隔行跳过
+        if (cells.every(c => /^[-:]+$/.test(c)))
+            continue;
+        // 表头行跳过
+        if (cells.some(c => c === '功能模块' || c === '模块'))
+            continue;
+        // 数据行：第1列或第2列是模块名
+        const moduleName = cells[0] && cells[0] !== '功能模块' ? cells[0] : (cells[1] || '');
+        if (!moduleName || moduleName.length < 2)
+            continue;
+        // 跳过状态标记行
+        if (moduleName.startsWith('#'))
+            continue;
+        // 添加到映射
+        const existing = modulePlatformMap.get(moduleName) || [];
+        if (!existing.includes(currentPlatform)) {
+            existing.push(currentPlatform);
+        }
+        modulePlatformMap.set(moduleName, existing);
+    }
+    // 转换为结果数组
+    const modules = [];
+    for (const [name, platforms] of modulePlatformMap) {
+        modules.push({ name, platforms: platforms.length > 0 ? platforms : [...allPlatforms] });
+    }
+    return modules;
+}
+/**
+ * v6.70.0+: 解析 FUNCTION_MAP.md 跨端功能映射表
+ * 支持两种格式：
+ *   1. Markdown 表格（功能单元 | 涉及端 | ...）
+ *   2. 树形格式（├── 模块名 ... platform1 ✅ | platform2 ✅）
+ * 返回功能单元列表，含涉及端、共享能力、依赖关系
+ */
+function parseFunctionMap(content, allPlatforms) {
+    // v7.4.2+: 先尝试表格格式
+    const tableResult = parseFunctionMapTable(content, allPlatforms);
+    if (tableResult.length > 0)
+        return tableResult;
+    // v7.4.2+: 回退到树形格式解析
+    return parseFunctionMapTree(content, allPlatforms);
+}
+/**
+ * v7.4.2+: 解析 FUNCTION_MAP.md 表格格式
+ */
+function parseFunctionMapTable(content, allPlatforms) {
+    const units = [];
+    const lines = content.split(/\r?\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;
+        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;
+}
+/**
+ * v7.4.2+: 解析 FUNCTION_MAP.md 树形格式
+ * 匹配: ├── 会议室 CRUD .............. room-service ✅ | admin-web ✅
+ * 提取: 模块名="会议室 CRUD", 涉及端=[room-service, admin-web]
+ */
+function parseFunctionMapTree(content, allPlatforms) {
+    const units = [];
+    const lines = content.split(/\r?\n/);
+    // 树形节点正则：匹配 ├── 或 └── 开头的行
+    const treeNodeRe = /[├└]──\s*/;
+    // 分隔点正则：匹配连续 .... 或 ———
+    const separatorRe = /\s*[.·]{3,}\s*/;
+    for (const line of lines) {
+        if (!treeNodeRe.test(line))
+            continue;
+        // 提取树节点后的文本
+        const afterTree = line.replace(/.*[├└]──\s*/, '').trim();
+        if (!afterTree)
+            continue;
+        // 跳过分类型节点（如 ├── 🏢 会议室管理），这些是父级分类
+        // 父级节点通常没有 ... 分隔符和平台标记
+        if (!separatorRe.test(afterTree) && !afterTree.includes('✅') && !afterTree.includes('❌') && !afterTree.includes('⚠️')) {
+            continue; // 这是分类父节点，跳过
+        }
+        // 分割模块名和平台部分
+        const parts = afterTree.split(separatorRe);
+        if (parts.length < 2)
+            continue;
+        // 模块名：去除 emoji 和空格
+        let unitName = parts[0].replace(/[🏢📅✅💰🔔👥📊⚙️🔑🛡️]/g, '').trim();
+        if (!unitName || unitName.length < 2)
+            continue;
+        // 平台部分：提取所有标准端名
+        const platformPart = parts.slice(1).join(' ');
+        const platforms = [];
+        for (const p of allPlatforms) {
+            if (platformPart.includes(p)) {
+                platforms.push(p);
+            }
+        }
+        // 如果没匹配到标准端名，尝试匹配常见缩写
+        if (platforms.length === 0) {
+            // 回退全端
+            platforms.push(...allPlatforms);
+        }
+        units.push({ name: unitName, platforms, sharedCapability: '无', dependsOn: [], description: '' });
+    }
+    return units;
+}
+/**
+ * v7.5.0+: 从 ANALYSIS.md 提取功能单元清单
+ * 支持两种格式：
+ *   A) 按端分节: ### X.X 端名（platform-name）— N 个页面 + | F-01 | 功能名 | ...
+ *   B) 按优先级分节: ### P0 — 必修 + 表格含「涉及端」列（v7.5.1+ 新增）
+ */
+function parseAnalysisFunctionalUnits(content, allPlatforms) {
+    const units = [];
+    const lines = content.split(/\r?\n/);
+    let currentPlatforms = [];
+    let platformColIdx = -1; // 「涉及端」列索引，-1 表示未检测到
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // 检测 ### 标题行，提取当前端名
+        if (line.startsWith('### ')) {
+            const prevPlatforms = [...currentPlatforms]; // 保留上一轮端信息
+            currentPlatforms = [];
+            // 匹配括号内的端名: ### 1.1 后台管理端（admin-web）
+            const parenMatch = line.match(/[（(]([a-zA-Z][\w-]*)[）)]/);
+            if (parenMatch) {
+                const name = parenMatch[1];
+                const matched = allPlatforms.filter(p => p === name || p.includes(name) || name.includes(p));
+                if (matched.length > 0)
+                    currentPlatforms.push(...matched);
+            }
+            // 回退：从标题文本匹配端名
+            if (currentPlatforms.length === 0) {
+                for (const p of allPlatforms) {
+                    if (line.includes(p)) {
+                        currentPlatforms.push(p);
+                    }
+                }
+            }
+            // 后端服务检测
+            if (currentPlatforms.length === 0 && /后端|服务|backend|service/i.test(line)) {
+                currentPlatforms.push(...allPlatforms.filter(p => /service|server|api|backend/i.test(p)));
+            }
+            // v7.5.1: 标题未匹配到端时，保留上一轮的 currentPlatforms（优先级分节场景）
+            if (currentPlatforms.length === 0) {
+                currentPlatforms = prevPlatforms;
+            }
+            // 遇到新章节，重置列索引（下一张表可能结构不同）
+            platformColIdx = -1;
+            continue;
+        }
+        // 解析表格行
+        if (!line.startsWith('|'))
+            continue;
+        const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+        if (cells.length < 2)
+            continue;
+        // 分隔行跳过
+        if (line.match(/^\|\s*[-:]/))
+            continue;
+        // 检测表头行：查找「涉及端」/「端」列
+        if (platformColIdx === -1) {
+            const idx = cells.findIndex(c => c === '涉及端' || c === '端' || c.includes('涉及端') || c.includes('涉及工程'));
+            if (idx >= 0) {
+                platformColIdx = idx;
+                continue; // 表头行本身不是数据
+            }
+        }
+        // 检测 F-xx 编号行（支持 | F-01 | 或 | # | 格式）
+        const idMatch = cells[0]?.match(/^F-(\d+)$/i);
+        if (!idMatch)
+            continue;
+        const id = `F-${idMatch[1]}`;
+        const name = cells[1]?.replace(/[*_`]/g, '').trim();
+        if (!name || name.length < 2)
+            continue;
+        // 提取描述（核心功能列，通常是第3或第4列）
+        const desc = cells.length >= 4 ? cells[3]?.trim() || '' : '';
+        // v7.5.1+: 优先从「涉及端」列提取平台（格式 B）
+        let rowPlatforms = [];
+        if (platformColIdx >= 0 && cells[platformColIdx]) {
+            const rawPlatform = cells[platformColIdx];
+            // 按逗号、+、顿号、空格分割
+            const parts = rawPlatform.split(/[,+、;\s]+/).map(s => s.trim()).filter(Boolean);
+            for (const part of parts) {
+                // 精确匹配
+                const exact = allPlatforms.find(p => p === part);
+                if (exact) {
+                    rowPlatforms.push(exact);
+                    continue;
+                }
+                // 模糊匹配（部分名包含）
+                const fuzzy = allPlatforms.filter(p => p.includes(part) || part.includes(p));
+                if (fuzzy.length > 0) {
+                    rowPlatforms.push(...fuzzy);
+                    continue;
+                }
+                // 中文端名映射（如 "后台管理端" → admin-web）
+                // 尝试从 CONSTITUTION 的「对应需求端」列匹配（此处简化：跳过中文值）
+            }
+            // 去重
+            rowPlatforms = [...new Set(rowPlatforms)];
+        }
+        // 回退优先级：涉及端列 → 章节标题 → 全部端
+        const platforms = rowPlatforms.length > 0
+            ? rowPlatforms
+            : (currentPlatforms.length > 0 ? [...currentPlatforms] : [...allPlatforms]);
+        units.push({ name, platforms, description: desc, id });
+    }
+    // 去重（按名称）
+    const seen = new Set();
+    return units.filter(u => {
+        if (seen.has(u.name))
+            return false;
+        seen.add(u.name);
+        return true;
+    });
+}
+/**
+ * 尝试模块驱动拆分：从功能模块创建任务目录结构
+ * 成功返回 true，无功能模块时返回 false（回退到传统流程）
+ */
+async function tryModuleDrivenSplit(iteration, iterationDir, options) {
+    const reqDir = (0, path_1.join)(iterationDir, '010-requirements');
+    const allPlatforms = await detectPlatforms(iterationDir);
+    // 收集功能模块（含涉及端信息）
+    const modules = [];
+    // v6.70.0+: 1. 优先从 overview/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)(functionMapPath, 'utf-8');
+            const parsed = parseFunctionMap(content, allPlatforms);
+            if (parsed.length > 0) {
+                for (const u of parsed) {
+                    modules.push({
+                        name: u.name,
+                        slug: slugify(u.name),
+                        type: 'feature',
+                        sourceFile: 'overview/FUNCTION_MAP.md',
+                        platforms: u.platforms,
+                        sharedCapability: u.sharedCapability,
+                        dependsOn: u.dependsOn,
+                        description: u.description,
+                    });
+                }
+                functionMapParsed = true;
+                logger_1.logger.info(`   📋 从 overview/FUNCTION_MAP.md 读取到 ${parsed.length} 个功能单元（严格按映射表拆分）`);
+            }
+        }
+        catch (e) {
+            logger_1.logger.debug('解析 FUNCTION_MAP.md 失败:', e);
+        }
+    }
+    // 2. 回退：从 overview/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 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: 'overview/REQUIREMENT.md',
+                            platforms: m.platforms,
+                        });
+                    }
+                    modulePlatformsParsed = true;
+                    logger_1.logger.info(`   📋 从 overview/REQUIREMENT.md 读取到 ${parsed.length} 个功能模块（含涉及端）`);
+                }
+            }
+            catch { }
+        }
+        // 2.5 v7.5.0+: 回退：从 ANALYSIS.md 提取功能单元清单（按端分节的 F-xx 表格）
+        if (!modulePlatformsParsed) {
+            const analysisPath = (0, path_1.join)(iterationDir, '020-specs', spec_paths_1.GLOBAL_SPECS_DIR, 'ANALYSIS.md');
+            if (await (0, fs_extra_1.pathExists)(analysisPath)) {
+                try {
+                    const content = await (0, fs_extra_1.readFile)(analysisPath, 'utf-8');
+                    const parsed = parseAnalysisFunctionalUnits(content, allPlatforms);
+                    if (parsed.length > 0) {
+                        for (const u of parsed) {
+                            modules.push({
+                                name: u.name,
+                                slug: slugify(u.name),
+                                type: 'feature',
+                                sourceFile: 'ANALYSIS.md',
+                                platforms: u.platforms,
+                                description: u.description,
+                            });
+                        }
+                        modulePlatformsParsed = true;
+                        logger_1.logger.info(`   📋 从 ANALYSIS.md 提取到 ${parsed.length} 个功能单元（F-xx 编号表）`);
+                    }
+                }
+                catch { }
+            }
+        }
+        // 3. 回退：读取 features/*/SOURCE.md（v8.3.226+，兼容旧 README.md）
+        // v8.3.249+: 优先读 _matrix.md 端声明（unitize 切分时写入），替代全端兜底——
+        // 此前全部配全端，单端功能（如仅 booking-service）也会拆出 4 个子任务
+        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 = await (0, feature_source_1.resolveUnitSourcePath)((0, path_1.join)(featuresDir, entry.name));
+                            if (await (0, fs_extra_1.pathExists)(readmePath)) {
+                                let unitPlatforms = [...allPlatforms];
+                                const matrixPath = (0, path_1.join)(featuresDir, entry.name, '_matrix.md');
+                                if (await (0, fs_extra_1.pathExists)(matrixPath)) {
+                                    const mc = await (0, fs_extra_1.readFile)(matrixPath, 'utf-8');
+                                    const m = mc.match(/^platforms:\s*\n((?:\s+-\s+\S+\s*\n?)+)/m);
+                                    if (m) {
+                                        const declared = m[1].split('\n')
+                                            .map(l => l.replace(/^\s+-\s+/, '').trim()).filter(Boolean);
+                                        if (declared.length > 0) {
+                                            unitPlatforms = declared.filter(p => allPlatforms.includes(p));
+                                        }
+                                    }
+                                }
+                                modules.push({
+                                    name: entry.name, slug: slugify(entry.name), type: 'feature',
+                                    sourceFile: `features/${entry.name}/${(0, path_1.basename)(readmePath)}`,
+                                    platforms: unitPlatforms,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    // 3. 读取类型文档（bugs/refactors/research）
+    for (const typeDir of ['bugs', 'refactors', 'research']) {
+        const typeDirPath = (0, path_1.join)(reqDir, typeDir);
+        if (!(await (0, fs_extra_1.pathExists)(typeDirPath)))
+            continue;
+        try {
+            const entries = await (0, fs_extra_1.readdir)(typeDirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.md') && !(0, task_utils_1.isTimestampBackup)(entry.name)) {
+                    const slug = slugify(entry.name.replace('.md', ''));
+                    const taskType = typeDir === 'bugs' ? 'bugfix' : typeDir;
+                    modules.push({
+                        name: entry.name.replace('.md', ''), slug, type: taskType,
+                        sourceFile: `${typeDir}/${entry.name}`,
+                        platforms: [...allPlatforms],
+                    });
+                }
+            }
+        }
+        catch { }
+    }
+    if (modules.length === 0) {
+        return false; // 无功能模块，回退到传统流程
+    }
+    // v8.3.249+: --modules 过滤——模块驱动拆分此前完全忽略该选项，
+    // 指定单个单元时仍全量拆分（FUNCTION_MAP 全部单元照拆）
+    if (options.modules) {
+        const moduleFilters = options.modules.split(',').map(m => m.trim()).filter(Boolean);
+        const beforeCount = modules.length;
+        const filtered = modules.filter(mod => moduleFilters.some(f => mod.name.includes(f) || mod.slug.includes(f)));
+        if (filtered.length === 0) {
+            logger_1.logger.warn(`没有匹配 "${options.modules}" 的功能模块（可用: ${modules.slice(0, 5).map(m => m.name).join(', ')}${modules.length > 5 ? '...' : ''}），回退传统流程`);
+            return false;
+        }
+        modules.length = 0;
+        modules.push(...filtered);
+        logger_1.logger.info(`   🎯 模块过滤: ${beforeCount} → ${filtered.length}（只拆分: ${moduleFilters.join(', ')}）`);
+    }
+    // 检测已有任务
+    const existingTasks = await detectExistingTasks(iterationDir);
+    if (existingTasks.length > 0 && !options.force && !options.prune) {
+        logger_1.logger.warn(`   ⚠️  已有 ${existingTasks.length} 个任务: ${existingTasks.slice(0, 5).join(', ')}...`);
+        logger_1.logger.info('   使用 --force 强制覆盖 或 --prune 智能清理不匹配任务');
+        return true; // 已处理，不继续传统流程
+    }
+    // --force 清理所有旧任务
+    if (options.force) {
+        const tasksRoot = (0, path_1.join)(iterationDir, '030-tasks');
+        if (await (0, fs_extra_1.pathExists)(tasksRoot)) {
+            const entries = await (0, fs_extra_1.readdir)(tasksRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    await (0, fs_extra_1.remove)((0, path_1.join)(tasksRoot, entry.name));
+                }
+            }
+            logger_1.logger.info(`   🗑️  已清理旧任务目录`);
+        }
+    }
+    // v6.72.0+: --prune 智能清理不匹配的旧任务
+    if (options.prune && !options.force && existingTasks.length > 0) {
+        const tasksRoot = (0, path_1.join)(iterationDir, '030-tasks');
+        const validFeatureNames = new Set(modules.map(m => m.name));
+        const archiveDir = (0, path_1.join)(tasksRoot, '.archive', new Date().toISOString().split('T')[0]);
+        let prunedCount = 0;
+        for (const taskName of existingTasks) {
+            const taskDir = (0, path_1.join)(tasksRoot, taskName);
+            const featurePath = (0, path_1.join)(taskDir, '.meta', 'feature');
+            let featureName = '';
+            if (await (0, fs_extra_1.pathExists)(featurePath)) {
+                featureName = (await (0, fs_extra_1.readFile)(featurePath, 'utf-8')).trim();
+            }
+            // 如果功能单元不在当前 FUNCTION_MAP.md 中，移动到 archive
+            if (featureName && !validFeatureNames.has(featureName)) {
+                await (0, fs_extra_1.ensureDir)(archiveDir);
+                const { rename } = await Promise.resolve().then(() => __importStar(require('fs-extra')));
+                await rename(taskDir, (0, path_1.join)(archiveDir, taskName));
+                prunedCount++;
+                logger_1.logger.info(`   🗑️  已归档旧任务: ${taskName} (功能单元: ${featureName})`);
+            }
+        }
+        if (prunedCount > 0) {
+            logger_1.logger.info(`   📦 共归档 ${prunedCount} 个不匹配任务到 ${(0, path_1.relative)(tasksRoot, archiveDir)}`);
+        }
+        else {
+            logger_1.logger.info(`   ✅ 无需要清理的旧任务（所有任务功能单元均匹配）`);
+        }
+    }
+    logger_1.logger.info(`\n📦 模块驱动拆分: ${modules.length} 个功能模块`);
+    logger_1.logger.info(`   全局端列表: ${allPlatforms.join(', ')}`);
+    // 逐模块创建任务目录（按模块各自的涉及端）
+    const createdSections = [];
+    for (const mod of modules) {
+        const { id: taskId } = await (0, global_counters_1.nextTaskId)(mod.name, mod.slug);
+        const modPlatforms = mod.platforms.length > 0 ? mod.platforms : [...allPlatforms];
+        // v8.3.249+: section.content 从 sourceFile（SOURCE.md 等）读取——此前硬编码空串，
+        // 导致 REQ.md 四级回退全部落空（aiReq/analyzeReq/短 section.content 均不满足），
+        // 最终写出「待补充」骨架，execute 阶段拿不到有价值的需求文档
+        let sectionContent = '';
+        if (mod.sourceFile) {
+            try {
+                const srcPath = (0, path_1.join)(iterationDir, '010-requirements', mod.sourceFile);
+                if (await (0, fs_extra_1.pathExists)(srcPath)) {
+                    sectionContent = await (0, fs_extra_1.readFile)(srcPath, 'utf-8');
+                }
+            }
+            catch { /* 读取失败保持空 */ }
+        }
+        const section = {
+            name: mod.name,
+            content: sectionContent,
+            level: 2,
+        };
+        section._topic = mod.slug;
+        section._taskType = mod.type;
+        section._sourceFile = mod.sourceFile;
+        section._scopePlatforms = modPlatforms;
+        section._complexity = {
+            estimatedHours: 8,
+            priority: 'medium',
+        };
+        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(', ')})`);
+    }
+    // 生成任务总览
+    if (createdSections.length > 0) {
+        await generateImpactGraph(iterationDir, createdSections, allPlatforms);
+        logger_1.logger.info(`\n   📊 创建了 ${createdSections.length} 个任务（每端一个子任务）`);
+        // 生成内容填充提示
+        const fillPrompt = await buildContentFillingPrompt(iteration, iterationDir, createdSections, allPlatforms);
+        const promptsDir = (0, path_1.join)('.speccore', 'prompts');
+        await (0, fs_extra_1.ensureDir)(promptsDir);
+        await (0, fs_extra_1.writeFile)((0, path_1.join)(promptsDir, `split-content-${iteration}.md`), fillPrompt);
+        logger_1.logger.info(`   📝 内容填充提示 → .speccore/prompts/split-content-${iteration}.md`);
+    }
+    logger_1.logger.success(`✅ 模块驱动拆分完成: ${createdSections.length} 个任务`);
+    // 自动刷新知识图谱
+    try {
+        const { refreshKnowledgeGraph } = await Promise.resolve().then(() => __importStar(require('../../core/knowledge-graph')));
+        await refreshKnowledgeGraph(process.cwd(), iteration);
+        logger_1.logger.info('🧠 知识图谱已刷新');
+    }
+    catch { }
+    return true;
+}
+// v8.3.223+: 本地 assembleUnitContext 副本已收敛到 core/unit-context-assembler.ts 的
+// extractOverviewContext（此前两套实现并存、已漂移），本文件统一引用该实现
+/**
+ * 生成内容填充 Prompt — AI 为预创建的任务填充 REQ.md/TECH.md
+ * v7.4.2+: 每个功能单元注入精准上下文，而非让 AI 自己从全量文档中查找
+ */
+async function buildContentFillingPrompt(iteration, iterationDir, sections, allPlatforms) {
+    let p = `# 任务内容填充（模块驱动拆分）\n\n`;
+    p += `> 迭代: ${iteration} | 任务数: ${sections.length} | 端: ${allPlatforms.join(', ')}\n\n`;
+    p += `## 说明\n\n`;
+    p += `CLI 已按功能单元×端创建了任务目录结构，并为每个功能单元从分析文档中提取了相关上下文。\n`;
+    p += `你的任务是为每个子任务填充 REQ.md 和 TECH.md。\n\n`;
+    p += `## 全局上下文\n\n`;
+    p += `1. Read .speccore/CONSTITUTION.md — 项目配置\n`;
+    p += `2. Read 020-specs/overview/ANALYSIS.md — 迭代综合分析报告\n\n`;
+    p += `## 任务清单（含精准上下文）\n\n`;
+    for (const sec of sections) {
+        const taskId = sec._taskId || sec.name;
+        const sourceFile = sec._sourceFile || '';
+        const featureName = sec.functionalUnit || sec.name;
+        const modPlatforms = sec._scopePlatforms || allPlatforms;
+        p += `### ${taskId} — ${sec.name}\n`;
+        p += `- 功能单元: ${featureName}\n`;
+        p += `- 涉及端: ${modPlatforms.join(', ')}\n`;
+        if (sourceFile)
+            p += `- 来源: 010-requirements/${sourceFile}\n`;
+        p += `- 子任务目录: ${modPlatforms.map(pl => `${pl}/`).join(', ')}\n`;
+        p += `- 需要填充:\n`;
+        for (const platform of modPlatforms) {
+            p += `  - ${platform}/*/REQ.md — 子任务需求规格\n`;
+            p += `  - ${platform}/*/TECH.md — 子任务技术方案\n`;
+        }
+        // v7.4.2+: 注入该功能单元的精准上下文
+        const unitCtx = await (0, unit_context_assembler_1.extractOverviewContext)(iterationDir, featureName, modPlatforms);
+        p += `\n#### 📎 功能单元「${featureName}」相关上下文\n\n${unitCtx}\n\n`;
+        p += `\n`;
+    }
+    p += `## 填充规则\n\n`;
+    p += `1. 先 Read 子任务目录下的 TASK.md（已有基本信息）和 .meta/feature（功能单元名）\n`;
+    p += `2. REQ.md 和 TECH.md 已由 CLI 预创建（含骨架标记 + 质量标准），请用 Write 工具直接覆盖为专业内容\n`;
+    p += `3. REQ.md: 基于上方提供的「功能单元相关上下文」，撰写本子任务的需求规格\n`;
+    p += `4. TECH.md: 基于上下文中的接口定义和数据模型，细化本子任务的技术方案\n`;
+    p += `5. 同一功能模块的各端子任务要保持 API 契约一致（前后端接口签名必须匹配）\n`;
+    p += `6. 每个文件必须有实质性专业内容（最低 500 字符 / 30 行），禁止占位符残留\n`;
+    p += `7. REQ.md 必须 ≥ 50 行，TECH.md 必须 ≥ 80 行\n`;
+    p += `8. 自检：写入完成后检查行数和内容完整性，不达标需补全\n\n`;
+    // v8.1.0+: 注入子任务文档质量标准
+    p += `## 📋 子任务文档质量标准\n\n`;
+    p += `### REQ.md 必含内容\n`;
+    p += (0, spec_skeleton_1.buildQualityRubRIC)('REQ.md');
+    p += `\n### TECH.md 必含内容\n`;
+    p += (0, spec_skeleton_1.buildQualityRubRIC)('TECH.md');
+    p += `\n### 前后端契约一致性（关键）\n\n`;
+    p += `- 后端 TECH.md 的接口签名（路径/方法/参数/响应）必须与前端 TECH.md 的 API 调用清单完全匹配\n`;
+    p += `- 数据模型字段名、类型、必填性必须前后端一致\n`;
+    p += `- 状态枚举值必须前后端对齐\n\n`;
+    // v8.3.171+: 简化路径约束
+    p += `## ⚠️ 约束\n\n`;
+    p += `- 文件已预创建，只覆盖已有文件，不要创建新文件或新目录\n`;
+    p += `- 不要修改 .meta/ 下的文件\n`;
+    p += `- 不要修改 TASK.md（已由 CLI 生成）\n`;
+    p += '\n' + (0, questions_1.buildAutoModeInstruction)('split', iteration) + '\n';
+    return p;
+}
+//# sourceMappingURL=taskify.js.map